var BuilderBridge = (() => {
  // ../../../node_modules/.pnpm/rrweb@2.0.0-alpha.20/node_modules/rrweb/dist/rrweb.js
  var __defProp = Object.defineProperty;
  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
  var _a;
  var __defProp$1 = Object.defineProperty;
  var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
  var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
  var NodeType$3 = /* @__PURE__ */ ((NodeType22) => {
    NodeType22[NodeType22["Document"] = 0] = "Document";
    NodeType22[NodeType22["DocumentType"] = 1] = "DocumentType";
    NodeType22[NodeType22["Element"] = 2] = "Element";
    NodeType22[NodeType22["Text"] = 3] = "Text";
    NodeType22[NodeType22["CDATA"] = 4] = "CDATA";
    NodeType22[NodeType22["Comment"] = 5] = "Comment";
    return NodeType22;
  })(NodeType$3 || {});
  var testableAccessors$1 = {
    Node: [
      "childNodes",
      "parentNode",
      "parentElement",
      "textContent",
      "ownerDocument"
    ],
    ShadowRoot: ["host", "styleSheets"],
    Element: ["shadowRoot", "querySelector", "querySelectorAll"],
    MutationObserver: []
  };
  var testableMethods$1 = {
    Node: ["contains", "getRootNode"],
    ShadowRoot: ["getSelection"],
    Element: [],
    MutationObserver: ["constructor"]
  };
  var untaintedBasePrototype$1 = {};
  var isAngularZonePresent$1 = () => {
    return !!globalThis.Zone;
  };
  function getUntaintedPrototype$1(key) {
    if (untaintedBasePrototype$1[key])
      return untaintedBasePrototype$1[key];
    const defaultObj = globalThis[key];
    const defaultPrototype = defaultObj.prototype;
    const accessorNames = key in testableAccessors$1 ? testableAccessors$1[key] : void 0;
    const isUntaintedAccessors = Boolean(
      accessorNames && // @ts-expect-error 2345
      accessorNames.every(
        (accessor) => {
          var _a2, _b;
          return Boolean(
            (_b = (_a2 = Object.getOwnPropertyDescriptor(defaultPrototype, accessor)) == null ? void 0 : _a2.get) == null ? void 0 : _b.toString().includes("[native code]")
          );
        }
      )
    );
    const methodNames = key in testableMethods$1 ? testableMethods$1[key] : void 0;
    const isUntaintedMethods = Boolean(
      methodNames && methodNames.every(
        // @ts-expect-error 2345
        (method) => {
          var _a2;
          return typeof defaultPrototype[method] === "function" && ((_a2 = defaultPrototype[method]) == null ? void 0 : _a2.toString().includes("[native code]"));
        }
      )
    );
    if (isUntaintedAccessors && isUntaintedMethods && !isAngularZonePresent$1()) {
      untaintedBasePrototype$1[key] = defaultObj.prototype;
      return defaultObj.prototype;
    }
    try {
      const iframeEl = document.createElement("iframe");
      document.body.appendChild(iframeEl);
      const win = iframeEl.contentWindow;
      if (!win) return defaultObj.prototype;
      const untaintedObject = win[key].prototype;
      document.body.removeChild(iframeEl);
      if (!untaintedObject) return defaultPrototype;
      return untaintedBasePrototype$1[key] = untaintedObject;
    } catch {
      return defaultPrototype;
    }
  }
  var untaintedAccessorCache$1 = {};
  function getUntaintedAccessor$1(key, instance, accessor) {
    var _a2;
    const cacheKey = `${key}.${String(accessor)}`;
    if (untaintedAccessorCache$1[cacheKey])
      return untaintedAccessorCache$1[cacheKey].call(
        instance
      );
    const untaintedPrototype = getUntaintedPrototype$1(key);
    const untaintedAccessor = (_a2 = Object.getOwnPropertyDescriptor(
      untaintedPrototype,
      accessor
    )) == null ? void 0 : _a2.get;
    if (!untaintedAccessor) return instance[accessor];
    untaintedAccessorCache$1[cacheKey] = untaintedAccessor;
    return untaintedAccessor.call(instance);
  }
  var untaintedMethodCache$1 = {};
  function getUntaintedMethod$1(key, instance, method) {
    const cacheKey = `${key}.${String(method)}`;
    if (untaintedMethodCache$1[cacheKey])
      return untaintedMethodCache$1[cacheKey].bind(
        instance
      );
    const untaintedPrototype = getUntaintedPrototype$1(key);
    const untaintedMethod = untaintedPrototype[method];
    if (typeof untaintedMethod !== "function") return instance[method];
    untaintedMethodCache$1[cacheKey] = untaintedMethod;
    return untaintedMethod.bind(instance);
  }
  function ownerDocument$1(n2) {
    return getUntaintedAccessor$1("Node", n2, "ownerDocument");
  }
  function childNodes$1(n2) {
    return getUntaintedAccessor$1("Node", n2, "childNodes");
  }
  function parentNode$1(n2) {
    return getUntaintedAccessor$1("Node", n2, "parentNode");
  }
  function parentElement$1(n2) {
    return getUntaintedAccessor$1("Node", n2, "parentElement");
  }
  function textContent$1(n2) {
    return getUntaintedAccessor$1("Node", n2, "textContent");
  }
  function contains$1(n2, other) {
    return getUntaintedMethod$1("Node", n2, "contains")(other);
  }
  function getRootNode$1(n2) {
    return getUntaintedMethod$1("Node", n2, "getRootNode")();
  }
  function host$1(n2) {
    if (!n2 || !("host" in n2)) return null;
    return getUntaintedAccessor$1("ShadowRoot", n2, "host");
  }
  function styleSheets$1(n2) {
    return n2.styleSheets;
  }
  function shadowRoot$1(n2) {
    if (!n2 || !("shadowRoot" in n2)) return null;
    return getUntaintedAccessor$1("Element", n2, "shadowRoot");
  }
  function querySelector$1(n2, selectors) {
    return getUntaintedAccessor$1("Element", n2, "querySelector")(selectors);
  }
  function querySelectorAll$1(n2, selectors) {
    return getUntaintedAccessor$1("Element", n2, "querySelectorAll")(selectors);
  }
  function mutationObserverCtor$1() {
    return getUntaintedPrototype$1("MutationObserver").constructor;
  }
  function patch$1(source, name, replacement) {
    try {
      if (!(name in source)) {
        return () => {
        };
      }
      const original = source[name];
      const wrapped = replacement(original);
      if (typeof wrapped === "function") {
        wrapped.prototype = wrapped.prototype || {};
        Object.defineProperties(wrapped, {
          __rrweb_original__: {
            enumerable: false,
            value: original
          }
        });
      }
      source[name] = wrapped;
      return () => {
        source[name] = original;
      };
    } catch {
      return () => {
      };
    }
  }
  var index$1 = {
    ownerDocument: ownerDocument$1,
    childNodes: childNodes$1,
    parentNode: parentNode$1,
    parentElement: parentElement$1,
    textContent: textContent$1,
    contains: contains$1,
    getRootNode: getRootNode$1,
    host: host$1,
    styleSheets: styleSheets$1,
    shadowRoot: shadowRoot$1,
    querySelector: querySelector$1,
    querySelectorAll: querySelectorAll$1,
    mutationObserver: mutationObserverCtor$1,
    patch: patch$1
  };
  function isElement(n2) {
    return n2.nodeType === n2.ELEMENT_NODE;
  }
  function isShadowRoot(n2) {
    const hostEl = (
      // anchor and textarea elements also have a `host` property
      // but only shadow roots have a `mode` property
      n2 && "host" in n2 && "mode" in n2 && index$1.host(n2) || null
    );
    return Boolean(
      hostEl && "shadowRoot" in hostEl && index$1.shadowRoot(hostEl) === n2
    );
  }
  function isNativeShadowDom(shadowRoot2) {
    return Object.prototype.toString.call(shadowRoot2) === "[object ShadowRoot]";
  }
  function fixBrowserCompatibilityIssuesInCSS(cssText) {
    if (cssText.includes(" background-clip: text;") && !cssText.includes(" -webkit-background-clip: text;")) {
      cssText = cssText.replace(
        /\sbackground-clip:\s*text;/g,
        " -webkit-background-clip: text; background-clip: text;"
      );
    }
    return cssText;
  }
  function escapeImportStatement(rule2) {
    const { cssText } = rule2;
    if (cssText.split('"').length < 3) return cssText;
    const statement = ["@import", `url(${JSON.stringify(rule2.href)})`];
    if (rule2.layerName === "") {
      statement.push(`layer`);
    } else if (rule2.layerName) {
      statement.push(`layer(${rule2.layerName})`);
    }
    if (rule2.supportsText) {
      statement.push(`supports(${rule2.supportsText})`);
    }
    if (rule2.media.length) {
      statement.push(rule2.media.mediaText);
    }
    return statement.join(" ") + ";";
  }
  function stringifyStylesheet(s2) {
    try {
      const rules2 = s2.rules || s2.cssRules;
      if (!rules2) {
        return null;
      }
      let sheetHref = s2.href;
      if (!sheetHref && s2.ownerNode) {
        sheetHref = s2.ownerNode.baseURI;
      }
      const stringifiedRules = Array.from(
        rules2,
        (rule2) => stringifyRule(rule2, sheetHref)
      ).join("");
      return fixBrowserCompatibilityIssuesInCSS(stringifiedRules);
    } catch (error) {
      return null;
    }
  }
  function stringifyRule(rule2, sheetHref) {
    if (isCSSImportRule(rule2)) {
      let importStringified;
      try {
        importStringified = // for same-origin stylesheets,
        // we can access the imported stylesheet rules directly
        stringifyStylesheet(rule2.styleSheet) || // work around browser issues with the raw string `@import url(...)` statement
        escapeImportStatement(rule2);
      } catch (error) {
        importStringified = rule2.cssText;
      }
      if (rule2.styleSheet.href) {
        return absolutifyURLs(importStringified, rule2.styleSheet.href);
      }
      return importStringified;
    } else {
      let ruleStringified = rule2.cssText;
      if (isCSSStyleRule(rule2) && rule2.selectorText.includes(":")) {
        ruleStringified = fixSafariColons(ruleStringified);
      }
      if (sheetHref) {
        return absolutifyURLs(ruleStringified, sheetHref);
      }
      return ruleStringified;
    }
  }
  function fixSafariColons(cssStringified) {
    const regex = /(\[(?:[\w-]+)[^\\])(:(?:[\w-]+)\])/gm;
    return cssStringified.replace(regex, "$1\\$2");
  }
  function isCSSImportRule(rule2) {
    return "styleSheet" in rule2;
  }
  function isCSSStyleRule(rule2) {
    return "selectorText" in rule2;
  }
  var Mirror = class {
    constructor() {
      __publicField$1(this, "idNodeMap", /* @__PURE__ */ new Map());
      __publicField$1(this, "nodeMetaMap", /* @__PURE__ */ new WeakMap());
    }
    getId(n2) {
      var _a2;
      if (!n2) return -1;
      const id = (_a2 = this.getMeta(n2)) == null ? void 0 : _a2.id;
      return id ?? -1;
    }
    getNode(id) {
      return this.idNodeMap.get(id) || null;
    }
    getIds() {
      return Array.from(this.idNodeMap.keys());
    }
    getMeta(n2) {
      return this.nodeMetaMap.get(n2) || null;
    }
    // removes the node from idNodeMap
    // doesn't remove the node from nodeMetaMap
    removeNodeFromMap(n2) {
      const id = this.getId(n2);
      this.idNodeMap.delete(id);
      if (n2.childNodes) {
        n2.childNodes.forEach(
          (childNode) => this.removeNodeFromMap(childNode)
        );
      }
    }
    has(id) {
      return this.idNodeMap.has(id);
    }
    hasNode(node2) {
      return this.nodeMetaMap.has(node2);
    }
    add(n2, meta) {
      const id = meta.id;
      this.idNodeMap.set(id, n2);
      this.nodeMetaMap.set(n2, meta);
    }
    replace(id, n2) {
      const oldNode = this.getNode(id);
      if (oldNode) {
        const meta = this.nodeMetaMap.get(oldNode);
        if (meta) this.nodeMetaMap.set(n2, meta);
      }
      this.idNodeMap.set(id, n2);
    }
    reset() {
      this.idNodeMap = /* @__PURE__ */ new Map();
      this.nodeMetaMap = /* @__PURE__ */ new WeakMap();
    }
  };
  function createMirror$2() {
    return new Mirror();
  }
  function maskInputValue({
    element,
    maskInputOptions,
    tagName,
    type,
    value,
    maskInputFn
  }) {
    let text = value || "";
    const actualType = type && toLowerCase(type);
    if (maskInputOptions[tagName.toLowerCase()] || actualType && maskInputOptions[actualType]) {
      if (maskInputFn) {
        text = maskInputFn(text, element);
      } else {
        text = "*".repeat(text.length);
      }
    }
    return text;
  }
  function toLowerCase(str) {
    return str.toLowerCase();
  }
  var ORIGINAL_ATTRIBUTE_NAME = "__rrweb_original__";
  function is2DCanvasBlank(canvas) {
    const ctx = canvas.getContext("2d");
    if (!ctx) return true;
    const chunkSize = 50;
    for (let x2 = 0; x2 < canvas.width; x2 += chunkSize) {
      for (let y = 0; y < canvas.height; y += chunkSize) {
        const getImageData = ctx.getImageData;
        const originalGetImageData = ORIGINAL_ATTRIBUTE_NAME in getImageData ? getImageData[ORIGINAL_ATTRIBUTE_NAME] : getImageData;
        const pixelBuffer = new Uint32Array(
          // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
          originalGetImageData.call(
            ctx,
            x2,
            y,
            Math.min(chunkSize, canvas.width - x2),
            Math.min(chunkSize, canvas.height - y)
          ).data.buffer
        );
        if (pixelBuffer.some((pixel) => pixel !== 0)) return false;
      }
    }
    return true;
  }
  function getInputType(element) {
    const type = element.type;
    return element.hasAttribute("data-rr-is-password") ? "password" : type ? (
      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
      toLowerCase(type)
    ) : null;
  }
  function extractFileExtension(path, baseURL) {
    let url;
    try {
      url = new URL(path, baseURL ?? window.location.href);
    } catch (err) {
      return null;
    }
    const regex = /\.([0-9a-z]+)(?:$)/i;
    const match = url.pathname.match(regex);
    return (match == null ? void 0 : match[1]) ?? null;
  }
  function extractOrigin(url) {
    let origin = "";
    if (url.indexOf("//") > -1) {
      origin = url.split("/").slice(0, 3).join("/");
    } else {
      origin = url.split("/")[0];
    }
    origin = origin.split("?")[0];
    return origin;
  }
  var URL_IN_CSS_REF = /url\((?:(')([^']*)'|(")(.*?)"|([^)]*))\)/gm;
  var URL_PROTOCOL_MATCH = /^(?:[a-z+]+:)?\/\//i;
  var URL_WWW_MATCH = /^www\..*/i;
  var DATA_URI = /^(data:)([^,]*),(.*)/i;
  function absolutifyURLs(cssText, href) {
    return (cssText || "").replace(
      URL_IN_CSS_REF,
      (origin, quote1, path1, quote2, path2, path3) => {
        const filePath = path1 || path2 || path3;
        const maybeQuote = quote1 || quote2 || "";
        if (!filePath) {
          return origin;
        }
        if (URL_PROTOCOL_MATCH.test(filePath) || URL_WWW_MATCH.test(filePath)) {
          return `url(${maybeQuote}${filePath}${maybeQuote})`;
        }
        if (DATA_URI.test(filePath)) {
          return `url(${maybeQuote}${filePath}${maybeQuote})`;
        }
        if (filePath[0] === "/") {
          return `url(${maybeQuote}${extractOrigin(href) + filePath}${maybeQuote})`;
        }
        const stack = href.split("/");
        const parts = filePath.split("/");
        stack.pop();
        for (const part of parts) {
          if (part === ".") {
            continue;
          } else if (part === "..") {
            stack.pop();
          } else {
            stack.push(part);
          }
        }
        return `url(${maybeQuote}${stack.join("/")}${maybeQuote})`;
      }
    );
  }
  function normalizeCssString(cssText, _testNoPxNorm = false) {
    if (_testNoPxNorm) {
      return cssText.replace(/(\/\*[^*]*\*\/)|[\s;]/g, "");
    } else {
      return cssText.replace(/(\/\*[^*]*\*\/)|[\s;]/g, "").replace(/0px/g, "0");
    }
  }
  function splitCssText(cssText, style, _testNoPxNorm = false) {
    const childNodes2 = Array.from(style.childNodes);
    const splits = [];
    let iterCount = 0;
    if (childNodes2.length > 1 && cssText && typeof cssText === "string") {
      let cssTextNorm = normalizeCssString(cssText, _testNoPxNorm);
      const normFactor = cssTextNorm.length / cssText.length;
      for (let i2 = 1; i2 < childNodes2.length; i2++) {
        if (childNodes2[i2].textContent && typeof childNodes2[i2].textContent === "string") {
          const textContentNorm = normalizeCssString(
            childNodes2[i2].textContent,
            _testNoPxNorm
          );
          const jLimit = 100;
          let j = 3;
          for (; j < textContentNorm.length; j++) {
            if (
              // keep consuming css identifiers (to get a decent chunk more quickly)
              textContentNorm[j].match(/[a-zA-Z0-9]/) || // substring needs to be unique to this section
              textContentNorm.indexOf(textContentNorm.substring(0, j), 1) !== -1
            ) {
              continue;
            }
            break;
          }
          for (; j < textContentNorm.length; j++) {
            let startSubstring = textContentNorm.substring(0, j);
            let cssNormSplits = cssTextNorm.split(startSubstring);
            let splitNorm = -1;
            if (cssNormSplits.length === 2) {
              splitNorm = cssNormSplits[0].length;
            } else if (cssNormSplits.length > 2 && cssNormSplits[0] === "" && childNodes2[i2 - 1].textContent !== "") {
              splitNorm = cssTextNorm.indexOf(startSubstring, 1);
            } else if (cssNormSplits.length === 1) {
              startSubstring = startSubstring.substring(
                0,
                startSubstring.length - 1
              );
              cssNormSplits = cssTextNorm.split(startSubstring);
              if (cssNormSplits.length <= 1) {
                splits.push(cssText);
                return splits;
              }
              j = jLimit + 1;
            } else if (j === textContentNorm.length - 1) {
              splitNorm = cssTextNorm.indexOf(startSubstring);
            }
            if (cssNormSplits.length >= 2 && j > jLimit) {
              const prevTextContent = childNodes2[i2 - 1].textContent;
              if (prevTextContent && typeof prevTextContent === "string") {
                const prevMinLength = normalizeCssString(prevTextContent).length;
                splitNorm = cssTextNorm.indexOf(startSubstring, prevMinLength);
              }
              if (splitNorm === -1) {
                splitNorm = cssNormSplits[0].length;
              }
            }
            if (splitNorm !== -1) {
              let k = Math.floor(splitNorm / normFactor);
              for (; k > 0 && k < cssText.length; ) {
                iterCount += 1;
                if (iterCount > 50 * childNodes2.length) {
                  splits.push(cssText);
                  return splits;
                }
                const normPart = normalizeCssString(
                  cssText.substring(0, k),
                  _testNoPxNorm
                );
                if (normPart.length === splitNorm) {
                  splits.push(cssText.substring(0, k));
                  cssText = cssText.substring(k);
                  cssTextNorm = cssTextNorm.substring(splitNorm);
                  break;
                } else if (normPart.length < splitNorm) {
                  k += Math.max(
                    1,
                    Math.floor((splitNorm - normPart.length) / normFactor)
                  );
                } else {
                  k -= Math.max(
                    1,
                    Math.floor((normPart.length - splitNorm) * normFactor)
                  );
                }
              }
              break;
            }
          }
        }
      }
    }
    splits.push(cssText);
    return splits;
  }
  function markCssSplits(cssText, style) {
    return splitCssText(cssText, style).join("/* rr_split */");
  }
  var _id = 1;
  var tagNameRegex = new RegExp("[^a-z0-9-_:]");
  var IGNORED_NODE = -2;
  function genId() {
    return _id++;
  }
  function getValidTagName$1(element) {
    if (element instanceof HTMLFormElement) {
      return "form";
    }
    const processedTagName = toLowerCase(element.tagName);
    if (tagNameRegex.test(processedTagName)) {
      return "div";
    }
    return processedTagName;
  }
  var canvasService;
  var canvasCtx;
  var SRCSET_NOT_SPACES = /^[^ \t\n\r\u000c]+/;
  var SRCSET_COMMAS_OR_SPACES = /^[, \t\n\r\u000c]+/;
  function getAbsoluteSrcsetString(doc, attributeValue) {
    if (attributeValue.trim() === "") {
      return attributeValue;
    }
    let pos = 0;
    function collectCharacters(regEx) {
      let chars2;
      const match = regEx.exec(attributeValue.substring(pos));
      if (match) {
        chars2 = match[0];
        pos += chars2.length;
        return chars2;
      }
      return "";
    }
    const output = [];
    while (true) {
      collectCharacters(SRCSET_COMMAS_OR_SPACES);
      if (pos >= attributeValue.length) {
        break;
      }
      let url = collectCharacters(SRCSET_NOT_SPACES);
      if (url.slice(-1) === ",") {
        url = absoluteToDoc(doc, url.substring(0, url.length - 1));
        output.push(url);
      } else {
        let descriptorsStr = "";
        url = absoluteToDoc(doc, url);
        let inParens = false;
        while (true) {
          const c2 = attributeValue.charAt(pos);
          if (c2 === "") {
            output.push((url + descriptorsStr).trim());
            break;
          } else if (!inParens) {
            if (c2 === ",") {
              pos += 1;
              output.push((url + descriptorsStr).trim());
              break;
            } else if (c2 === "(") {
              inParens = true;
            }
          } else {
            if (c2 === ")") {
              inParens = false;
            }
          }
          descriptorsStr += c2;
          pos += 1;
        }
      }
    }
    return output.join(", ");
  }
  var cachedDocument = /* @__PURE__ */ new WeakMap();
  function absoluteToDoc(doc, attributeValue) {
    if (!attributeValue || attributeValue.trim() === "") {
      return attributeValue;
    }
    return getHref(doc, attributeValue);
  }
  function isSVGElement(el) {
    return Boolean(el.tagName === "svg" || el.ownerSVGElement);
  }
  function getHref(doc, customHref) {
    let a2 = cachedDocument.get(doc);
    if (!a2) {
      a2 = doc.createElement("a");
      cachedDocument.set(doc, a2);
    }
    if (!customHref) {
      customHref = "";
    } else if (customHref.startsWith("blob:") || customHref.startsWith("data:")) {
      return customHref;
    }
    a2.setAttribute("href", customHref);
    return a2.href;
  }
  function transformAttribute(doc, tagName, name, value) {
    if (!value) {
      return value;
    }
    if (name === "src" || name === "href" && !(tagName === "use" && value[0] === "#")) {
      return absoluteToDoc(doc, value);
    } else if (name === "xlink:href" && value[0] !== "#") {
      return absoluteToDoc(doc, value);
    } else if (name === "background" && ["table", "td", "th"].includes(tagName)) {
      return absoluteToDoc(doc, value);
    } else if (name === "srcset") {
      return getAbsoluteSrcsetString(doc, value);
    } else if (name === "style") {
      return absolutifyURLs(value, getHref(doc));
    } else if (tagName === "object" && name === "data") {
      return absoluteToDoc(doc, value);
    }
    return value;
  }
  function ignoreAttribute(tagName, name, _value) {
    return ["video", "audio"].includes(tagName) && name === "autoplay";
  }
  function _isBlockedElement(element, blockClass, blockSelector) {
    try {
      if (typeof blockClass === "string") {
        if (element.classList.contains(blockClass)) {
          return true;
        }
      } else {
        for (let eIndex = element.classList.length; eIndex--; ) {
          const className = element.classList[eIndex];
          if (blockClass.test(className)) {
            return true;
          }
        }
      }
      if (blockSelector) {
        return element.matches(blockSelector);
      }
    } catch (e2) {
    }
    return false;
  }
  function classMatchesRegex(node2, regex, checkAncestors) {
    if (!node2) return false;
    if (node2.nodeType !== node2.ELEMENT_NODE) {
      if (!checkAncestors) return false;
      return classMatchesRegex(index$1.parentNode(node2), regex, checkAncestors);
    }
    for (let eIndex = node2.classList.length; eIndex--; ) {
      const className = node2.classList[eIndex];
      if (regex.test(className)) {
        return true;
      }
    }
    if (!checkAncestors) return false;
    return classMatchesRegex(index$1.parentNode(node2), regex, checkAncestors);
  }
  function needMaskingText(node2, maskTextClass, maskTextSelector, checkAncestors) {
    let el;
    if (isElement(node2)) {
      el = node2;
      if (!index$1.childNodes(el).length) {
        return false;
      }
    } else if (index$1.parentElement(node2) === null) {
      return false;
    } else {
      el = index$1.parentElement(node2);
    }
    try {
      if (typeof maskTextClass === "string") {
        if (checkAncestors) {
          if (el.closest(`.${maskTextClass}`)) return true;
        } else {
          if (el.classList.contains(maskTextClass)) return true;
        }
      } else {
        if (classMatchesRegex(el, maskTextClass, checkAncestors)) return true;
      }
      if (maskTextSelector) {
        if (checkAncestors) {
          if (el.closest(maskTextSelector)) return true;
        } else {
          if (el.matches(maskTextSelector)) return true;
        }
      }
    } catch (e2) {
    }
    return false;
  }
  function onceIframeLoaded(iframeEl, listener, iframeLoadTimeout) {
    const win = iframeEl.contentWindow;
    if (!win) {
      return;
    }
    let fired = false;
    let readyState;
    try {
      readyState = win.document.readyState;
    } catch (error) {
      return;
    }
    if (readyState !== "complete") {
      const timer = setTimeout(() => {
        if (!fired) {
          listener();
          fired = true;
        }
      }, iframeLoadTimeout);
      iframeEl.addEventListener("load", () => {
        clearTimeout(timer);
        fired = true;
        listener();
      });
      return;
    }
    const blankUrl = "about:blank";
    if (win.location.href !== blankUrl || iframeEl.src === blankUrl || iframeEl.src === "") {
      setTimeout(listener, 0);
      return iframeEl.addEventListener("load", listener);
    }
    iframeEl.addEventListener("load", listener);
  }
  function onceStylesheetLoaded(link, listener, styleSheetLoadTimeout) {
    let fired = false;
    let styleSheetLoaded;
    try {
      styleSheetLoaded = link.sheet;
    } catch (error) {
      return;
    }
    if (styleSheetLoaded) return;
    const timer = setTimeout(() => {
      if (!fired) {
        listener();
        fired = true;
      }
    }, styleSheetLoadTimeout);
    link.addEventListener("load", () => {
      clearTimeout(timer);
      fired = true;
      listener();
    });
  }
  function serializeNode(n2, options) {
    const {
      doc,
      mirror: mirror2,
      blockClass,
      blockSelector,
      needsMask,
      inlineStylesheet,
      maskInputOptions = {},
      maskTextFn,
      maskInputFn,
      dataURLOptions = {},
      inlineImages,
      recordCanvas,
      keepIframeSrcFn,
      newlyAddedElement = false,
      cssCaptured = false
    } = options;
    const rootId = getRootId(doc, mirror2);
    switch (n2.nodeType) {
      case n2.DOCUMENT_NODE:
        if (n2.compatMode !== "CSS1Compat") {
          return {
            type: NodeType$3.Document,
            childNodes: [],
            compatMode: n2.compatMode
            // probably "BackCompat"
          };
        } else {
          return {
            type: NodeType$3.Document,
            childNodes: []
          };
        }
      case n2.DOCUMENT_TYPE_NODE:
        return {
          type: NodeType$3.DocumentType,
          name: n2.name,
          publicId: n2.publicId,
          systemId: n2.systemId,
          rootId
        };
      case n2.ELEMENT_NODE:
        return serializeElementNode(n2, {
          doc,
          blockClass,
          blockSelector,
          inlineStylesheet,
          maskInputOptions,
          maskInputFn,
          dataURLOptions,
          inlineImages,
          recordCanvas,
          keepIframeSrcFn,
          newlyAddedElement,
          rootId
        });
      case n2.TEXT_NODE:
        return serializeTextNode(n2, {
          doc,
          needsMask,
          maskTextFn,
          rootId,
          cssCaptured
        });
      case n2.CDATA_SECTION_NODE:
        return {
          type: NodeType$3.CDATA,
          textContent: "",
          rootId
        };
      case n2.COMMENT_NODE:
        return {
          type: NodeType$3.Comment,
          textContent: index$1.textContent(n2) || "",
          rootId
        };
      default:
        return false;
    }
  }
  function getRootId(doc, mirror2) {
    if (!mirror2.hasNode(doc)) return void 0;
    const docId = mirror2.getId(doc);
    return docId === 1 ? void 0 : docId;
  }
  function serializeTextNode(n2, options) {
    const { needsMask, maskTextFn, rootId, cssCaptured } = options;
    const parent = index$1.parentNode(n2);
    const parentTagName = parent && parent.tagName;
    let textContent22 = "";
    const isStyle = parentTagName === "STYLE" ? true : void 0;
    const isScript = parentTagName === "SCRIPT" ? true : void 0;
    if (isScript) {
      textContent22 = "SCRIPT_PLACEHOLDER";
    } else if (!cssCaptured) {
      textContent22 = index$1.textContent(n2);
      if (isStyle && textContent22) {
        textContent22 = absolutifyURLs(textContent22, getHref(options.doc));
      }
    }
    if (!isStyle && !isScript && textContent22 && needsMask) {
      textContent22 = maskTextFn ? maskTextFn(textContent22, index$1.parentElement(n2)) : textContent22.replace(/[\S]/g, "*");
    }
    return {
      type: NodeType$3.Text,
      textContent: textContent22 || "",
      rootId
    };
  }
  function serializeElementNode(n2, options) {
    const {
      doc,
      blockClass,
      blockSelector,
      inlineStylesheet,
      maskInputOptions = {},
      maskInputFn,
      dataURLOptions = {},
      inlineImages,
      recordCanvas,
      keepIframeSrcFn,
      newlyAddedElement = false,
      rootId
    } = options;
    const needBlock = _isBlockedElement(n2, blockClass, blockSelector);
    const tagName = getValidTagName$1(n2);
    let attributes = {};
    const len = n2.attributes.length;
    for (let i2 = 0; i2 < len; i2++) {
      const attr = n2.attributes[i2];
      if (!ignoreAttribute(tagName, attr.name, attr.value)) {
        attributes[attr.name] = transformAttribute(
          doc,
          tagName,
          toLowerCase(attr.name),
          attr.value
        );
      }
    }
    if (tagName === "link" && inlineStylesheet) {
      const stylesheet = Array.from(doc.styleSheets).find((s2) => {
        return s2.href === n2.href;
      });
      let cssText = null;
      if (stylesheet) {
        cssText = stringifyStylesheet(stylesheet);
      }
      if (cssText) {
        delete attributes.rel;
        delete attributes.href;
        attributes._cssText = cssText;
      }
    }
    if (tagName === "style" && n2.sheet) {
      let cssText = stringifyStylesheet(
        n2.sheet
      );
      if (cssText) {
        if (n2.childNodes.length > 1) {
          cssText = markCssSplits(cssText, n2);
        }
        attributes._cssText = cssText;
      }
    }
    if (["input", "textarea", "select"].includes(tagName)) {
      const value = n2.value;
      const checked = n2.checked;
      if (attributes.type !== "radio" && attributes.type !== "checkbox" && attributes.type !== "submit" && attributes.type !== "button" && value) {
        attributes.value = maskInputValue({
          element: n2,
          type: getInputType(n2),
          tagName,
          value,
          maskInputOptions,
          maskInputFn
        });
      } else if (checked) {
        attributes.checked = checked;
      }
    }
    if (tagName === "option") {
      if (n2.selected && !maskInputOptions["select"]) {
        attributes.selected = true;
      } else {
        delete attributes.selected;
      }
    }
    if (tagName === "dialog" && n2.open) {
      attributes.rr_open_mode = n2.matches("dialog:modal") ? "modal" : "non-modal";
    }
    if (tagName === "canvas" && recordCanvas) {
      if (n2.__context === "2d") {
        if (!is2DCanvasBlank(n2)) {
          attributes.rr_dataURL = n2.toDataURL(
            dataURLOptions.type,
            dataURLOptions.quality
          );
        }
      } else if (!("__context" in n2)) {
        const canvasDataURL = n2.toDataURL(
          dataURLOptions.type,
          dataURLOptions.quality
        );
        const blankCanvas = doc.createElement("canvas");
        blankCanvas.width = n2.width;
        blankCanvas.height = n2.height;
        const blankCanvasDataURL = blankCanvas.toDataURL(
          dataURLOptions.type,
          dataURLOptions.quality
        );
        if (canvasDataURL !== blankCanvasDataURL) {
          attributes.rr_dataURL = canvasDataURL;
        }
      }
    }
    if (tagName === "img" && inlineImages) {
      if (!canvasService) {
        canvasService = doc.createElement("canvas");
        canvasCtx = canvasService.getContext("2d");
      }
      const image = n2;
      const imageSrc = image.currentSrc || image.getAttribute("src") || "<unknown-src>";
      const priorCrossOrigin = image.crossOrigin;
      const recordInlineImage = () => {
        image.removeEventListener("load", recordInlineImage);
        try {
          canvasService.width = image.naturalWidth;
          canvasService.height = image.naturalHeight;
          canvasCtx.drawImage(image, 0, 0);
          attributes.rr_dataURL = canvasService.toDataURL(
            dataURLOptions.type,
            dataURLOptions.quality
          );
        } catch (err) {
          if (image.crossOrigin !== "anonymous") {
            image.crossOrigin = "anonymous";
            if (image.complete && image.naturalWidth !== 0)
              recordInlineImage();
            else image.addEventListener("load", recordInlineImage);
            return;
          } else {
            console.warn(
              `Cannot inline img src=${imageSrc}! Error: ${err}`
            );
          }
        }
        if (image.crossOrigin === "anonymous") {
          priorCrossOrigin ? attributes.crossOrigin = priorCrossOrigin : image.removeAttribute("crossorigin");
        }
      };
      if (image.complete && image.naturalWidth !== 0) recordInlineImage();
      else image.addEventListener("load", recordInlineImage);
    }
    if (["audio", "video"].includes(tagName)) {
      const mediaAttributes = attributes;
      mediaAttributes.rr_mediaState = n2.paused ? "paused" : "played";
      mediaAttributes.rr_mediaCurrentTime = n2.currentTime;
      mediaAttributes.rr_mediaPlaybackRate = n2.playbackRate;
      mediaAttributes.rr_mediaMuted = n2.muted;
      mediaAttributes.rr_mediaLoop = n2.loop;
      mediaAttributes.rr_mediaVolume = n2.volume;
    }
    if (!newlyAddedElement) {
      if (n2.scrollLeft) {
        attributes.rr_scrollLeft = n2.scrollLeft;
      }
      if (n2.scrollTop) {
        attributes.rr_scrollTop = n2.scrollTop;
      }
    }
    if (needBlock) {
      const { width, height } = n2.getBoundingClientRect();
      attributes = {
        class: attributes.class,
        rr_width: `${width}px`,
        rr_height: `${height}px`
      };
    }
    if (tagName === "iframe" && !keepIframeSrcFn(attributes.src)) {
      if (!n2.contentDocument) {
        attributes.rr_src = attributes.src;
      }
      delete attributes.src;
    }
    let isCustomElement;
    try {
      if (customElements.get(tagName)) isCustomElement = true;
    } catch (e2) {
    }
    return {
      type: NodeType$3.Element,
      tagName,
      attributes,
      childNodes: [],
      isSVG: isSVGElement(n2) || void 0,
      needBlock,
      rootId,
      isCustom: isCustomElement
    };
  }
  function lowerIfExists(maybeAttr) {
    if (maybeAttr === void 0 || maybeAttr === null) {
      return "";
    } else {
      return maybeAttr.toLowerCase();
    }
  }
  function slimDOMDefaults(_slimDOMOptions) {
    if (_slimDOMOptions === true || _slimDOMOptions === "all") {
      return {
        script: true,
        comment: true,
        headFavicon: true,
        headWhitespace: true,
        headMetaSocial: true,
        headMetaRobots: true,
        headMetaHttpEquiv: true,
        headMetaVerification: true,
        // the following are off for slimDOMOptions === true,
        // as they destroy some (hidden) info:
        headMetaAuthorship: _slimDOMOptions === "all",
        headMetaDescKeywords: _slimDOMOptions === "all",
        headTitleMutations: _slimDOMOptions === "all"
      };
    } else if (_slimDOMOptions) {
      return _slimDOMOptions;
    }
    return {};
  }
  function slimDOMExcluded(sn, slimDOMOptions) {
    if (slimDOMOptions.comment && sn.type === NodeType$3.Comment) {
      return true;
    } else if (sn.type === NodeType$3.Element) {
      if (slimDOMOptions.script && // script tag
      (sn.tagName === "script" || // (module)preload link
      sn.tagName === "link" && (sn.attributes.rel === "preload" && sn.attributes.as === "script" || sn.attributes.rel === "modulepreload") || // prefetch link
      sn.tagName === "link" && sn.attributes.rel === "prefetch" && typeof sn.attributes.href === "string" && extractFileExtension(sn.attributes.href) === "js")) {
        return true;
      } else if (slimDOMOptions.headFavicon && (sn.tagName === "link" && sn.attributes.rel === "shortcut icon" || sn.tagName === "meta" && (lowerIfExists(sn.attributes.name).match(
        /^msapplication-tile(image|color)$/
      ) || lowerIfExists(sn.attributes.name) === "application-name" || lowerIfExists(sn.attributes.rel) === "icon" || lowerIfExists(sn.attributes.rel) === "apple-touch-icon" || lowerIfExists(sn.attributes.rel) === "shortcut icon"))) {
        return true;
      } else if (sn.tagName === "meta") {
        if (slimDOMOptions.headMetaDescKeywords && lowerIfExists(sn.attributes.name).match(/^description|keywords$/)) {
          return true;
        } else if (slimDOMOptions.headMetaSocial && (lowerIfExists(sn.attributes.property).match(/^(og|twitter|fb):/) || // og = opengraph (facebook)
        lowerIfExists(sn.attributes.name).match(/^(og|twitter):/) || lowerIfExists(sn.attributes.name) === "pinterest")) {
          return true;
        } else if (slimDOMOptions.headMetaRobots && (lowerIfExists(sn.attributes.name) === "robots" || lowerIfExists(sn.attributes.name) === "googlebot" || lowerIfExists(sn.attributes.name) === "bingbot")) {
          return true;
        } else if (slimDOMOptions.headMetaHttpEquiv && sn.attributes["http-equiv"] !== void 0) {
          return true;
        } else if (slimDOMOptions.headMetaAuthorship && (lowerIfExists(sn.attributes.name) === "author" || lowerIfExists(sn.attributes.name) === "generator" || lowerIfExists(sn.attributes.name) === "framework" || lowerIfExists(sn.attributes.name) === "publisher" || lowerIfExists(sn.attributes.name) === "progid" || lowerIfExists(sn.attributes.property).match(/^article:/) || lowerIfExists(sn.attributes.property).match(/^product:/))) {
          return true;
        } else if (slimDOMOptions.headMetaVerification && (lowerIfExists(sn.attributes.name) === "google-site-verification" || lowerIfExists(sn.attributes.name) === "yandex-verification" || lowerIfExists(sn.attributes.name) === "csrf-token" || lowerIfExists(sn.attributes.name) === "p:domain_verify" || lowerIfExists(sn.attributes.name) === "verify-v1" || lowerIfExists(sn.attributes.name) === "verification" || lowerIfExists(sn.attributes.name) === "shopify-checkout-api-token")) {
          return true;
        }
      }
    }
    return false;
  }
  function serializeNodeWithId(n2, options) {
    const {
      doc,
      mirror: mirror2,
      blockClass,
      blockSelector,
      maskTextClass,
      maskTextSelector,
      skipChild = false,
      inlineStylesheet = true,
      maskInputOptions = {},
      maskTextFn,
      maskInputFn,
      slimDOMOptions,
      dataURLOptions = {},
      inlineImages = false,
      recordCanvas = false,
      onSerialize,
      onIframeLoad,
      iframeLoadTimeout = 5e3,
      onStylesheetLoad,
      stylesheetLoadTimeout = 5e3,
      keepIframeSrcFn = () => false,
      newlyAddedElement = false,
      cssCaptured = false
    } = options;
    let { needsMask } = options;
    let { preserveWhiteSpace = true } = options;
    if (!needsMask) {
      const checkAncestors = needsMask === void 0;
      needsMask = needMaskingText(
        n2,
        maskTextClass,
        maskTextSelector,
        checkAncestors
      );
    }
    const _serializedNode = serializeNode(n2, {
      doc,
      mirror: mirror2,
      blockClass,
      blockSelector,
      needsMask,
      inlineStylesheet,
      maskInputOptions,
      maskTextFn,
      maskInputFn,
      dataURLOptions,
      inlineImages,
      recordCanvas,
      keepIframeSrcFn,
      newlyAddedElement,
      cssCaptured
    });
    if (!_serializedNode) {
      console.warn(n2, "not serialized");
      return null;
    }
    let id;
    if (mirror2.hasNode(n2)) {
      id = mirror2.getId(n2);
    } else if (slimDOMExcluded(_serializedNode, slimDOMOptions) || !preserveWhiteSpace && _serializedNode.type === NodeType$3.Text && !_serializedNode.textContent.replace(/^\s+|\s+$/gm, "").length) {
      id = IGNORED_NODE;
    } else {
      id = genId();
    }
    const serializedNode = Object.assign(_serializedNode, { id });
    mirror2.add(n2, serializedNode);
    if (id === IGNORED_NODE) {
      return null;
    }
    if (onSerialize) {
      onSerialize(n2);
    }
    let recordChild = !skipChild;
    if (serializedNode.type === NodeType$3.Element) {
      recordChild = recordChild && !serializedNode.needBlock;
      delete serializedNode.needBlock;
      const shadowRootEl = index$1.shadowRoot(n2);
      if (shadowRootEl && isNativeShadowDom(shadowRootEl))
        serializedNode.isShadowHost = true;
    }
    if ((serializedNode.type === NodeType$3.Document || serializedNode.type === NodeType$3.Element) && recordChild) {
      if (slimDOMOptions.headWhitespace && serializedNode.type === NodeType$3.Element && serializedNode.tagName === "head") {
        preserveWhiteSpace = false;
      }
      const bypassOptions = {
        doc,
        mirror: mirror2,
        blockClass,
        blockSelector,
        needsMask,
        maskTextClass,
        maskTextSelector,
        skipChild,
        inlineStylesheet,
        maskInputOptions,
        maskTextFn,
        maskInputFn,
        slimDOMOptions,
        dataURLOptions,
        inlineImages,
        recordCanvas,
        preserveWhiteSpace,
        onSerialize,
        onIframeLoad,
        iframeLoadTimeout,
        onStylesheetLoad,
        stylesheetLoadTimeout,
        keepIframeSrcFn,
        cssCaptured: false
      };
      if (serializedNode.type === NodeType$3.Element && serializedNode.tagName === "textarea" && serializedNode.attributes.value !== void 0) ;
      else {
        if (serializedNode.type === NodeType$3.Element && serializedNode.attributes._cssText !== void 0 && typeof serializedNode.attributes._cssText === "string") {
          bypassOptions.cssCaptured = true;
        }
        for (const childN of Array.from(index$1.childNodes(n2))) {
          const serializedChildNode = serializeNodeWithId(childN, bypassOptions);
          if (serializedChildNode) {
            serializedNode.childNodes.push(serializedChildNode);
          }
        }
      }
      let shadowRootEl = null;
      if (isElement(n2) && (shadowRootEl = index$1.shadowRoot(n2))) {
        for (const childN of Array.from(index$1.childNodes(shadowRootEl))) {
          const serializedChildNode = serializeNodeWithId(childN, bypassOptions);
          if (serializedChildNode) {
            isNativeShadowDom(shadowRootEl) && (serializedChildNode.isShadow = true);
            serializedNode.childNodes.push(serializedChildNode);
          }
        }
      }
    }
    const parent = index$1.parentNode(n2);
    if (parent && isShadowRoot(parent) && isNativeShadowDom(parent)) {
      serializedNode.isShadow = true;
    }
    if (serializedNode.type === NodeType$3.Element && serializedNode.tagName === "iframe") {
      onceIframeLoaded(
        n2,
        () => {
          const iframeDoc = n2.contentDocument;
          if (iframeDoc && onIframeLoad) {
            const serializedIframeNode = serializeNodeWithId(iframeDoc, {
              doc: iframeDoc,
              mirror: mirror2,
              blockClass,
              blockSelector,
              needsMask,
              maskTextClass,
              maskTextSelector,
              skipChild: false,
              inlineStylesheet,
              maskInputOptions,
              maskTextFn,
              maskInputFn,
              slimDOMOptions,
              dataURLOptions,
              inlineImages,
              recordCanvas,
              preserveWhiteSpace,
              onSerialize,
              onIframeLoad,
              iframeLoadTimeout,
              onStylesheetLoad,
              stylesheetLoadTimeout,
              keepIframeSrcFn
            });
            if (serializedIframeNode) {
              onIframeLoad(
                n2,
                serializedIframeNode
              );
            }
          }
        },
        iframeLoadTimeout
      );
    }
    if (serializedNode.type === NodeType$3.Element && serializedNode.tagName === "link" && typeof serializedNode.attributes.rel === "string" && (serializedNode.attributes.rel === "stylesheet" || serializedNode.attributes.rel === "preload" && typeof serializedNode.attributes.href === "string" && extractFileExtension(serializedNode.attributes.href) === "css")) {
      onceStylesheetLoaded(
        n2,
        () => {
          if (onStylesheetLoad) {
            const serializedLinkNode = serializeNodeWithId(n2, {
              doc,
              mirror: mirror2,
              blockClass,
              blockSelector,
              needsMask,
              maskTextClass,
              maskTextSelector,
              skipChild: false,
              inlineStylesheet,
              maskInputOptions,
              maskTextFn,
              maskInputFn,
              slimDOMOptions,
              dataURLOptions,
              inlineImages,
              recordCanvas,
              preserveWhiteSpace,
              onSerialize,
              onIframeLoad,
              iframeLoadTimeout,
              onStylesheetLoad,
              stylesheetLoadTimeout,
              keepIframeSrcFn
            });
            if (serializedLinkNode) {
              onStylesheetLoad(
                n2,
                serializedLinkNode
              );
            }
          }
        },
        stylesheetLoadTimeout
      );
    }
    return serializedNode;
  }
  function snapshot(n2, options) {
    const {
      mirror: mirror2 = new Mirror(),
      blockClass = "rr-block",
      blockSelector = null,
      maskTextClass = "rr-mask",
      maskTextSelector = null,
      inlineStylesheet = true,
      inlineImages = false,
      recordCanvas = false,
      maskAllInputs = false,
      maskTextFn,
      maskInputFn,
      slimDOM = false,
      dataURLOptions,
      preserveWhiteSpace,
      onSerialize,
      onIframeLoad,
      iframeLoadTimeout,
      onStylesheetLoad,
      stylesheetLoadTimeout,
      keepIframeSrcFn = () => false
    } = options || {};
    const maskInputOptions = maskAllInputs === true ? {
      color: true,
      date: true,
      "datetime-local": true,
      email: true,
      month: true,
      number: true,
      range: true,
      search: true,
      tel: true,
      text: true,
      time: true,
      url: true,
      week: true,
      textarea: true,
      select: true,
      password: true
    } : maskAllInputs === false ? {
      password: true
    } : maskAllInputs;
    const slimDOMOptions = slimDOMDefaults(slimDOM);
    return serializeNodeWithId(n2, {
      doc: n2,
      mirror: mirror2,
      blockClass,
      blockSelector,
      maskTextClass,
      maskTextSelector,
      skipChild: false,
      inlineStylesheet,
      maskInputOptions,
      maskTextFn,
      maskInputFn,
      slimDOMOptions,
      dataURLOptions,
      inlineImages,
      recordCanvas,
      preserveWhiteSpace,
      onSerialize,
      onIframeLoad,
      iframeLoadTimeout,
      onStylesheetLoad,
      stylesheetLoadTimeout,
      keepIframeSrcFn,
      newlyAddedElement: false
    });
  }
  var MEDIA_SELECTOR = /(max|min)-device-(width|height)/;
  var MEDIA_SELECTOR_GLOBAL = new RegExp(MEDIA_SELECTOR.source, "g");
  function getDefaultExportFromCjs$1(x2) {
    return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
  }
  function getAugmentedNamespace$1(n2) {
    if (n2.__esModule) return n2;
    var f2 = n2.default;
    if (typeof f2 == "function") {
      var a2 = function a22() {
        if (this instanceof a22) {
          return Reflect.construct(f2, arguments, this.constructor);
        }
        return f2.apply(this, arguments);
      };
      a2.prototype = f2.prototype;
    } else a2 = {};
    Object.defineProperty(a2, "__esModule", { value: true });
    Object.keys(n2).forEach(function(k) {
      var d = Object.getOwnPropertyDescriptor(n2, k);
      Object.defineProperty(a2, k, d.get ? d : {
        enumerable: true,
        get: function() {
          return n2[k];
        }
      });
    });
    return a2;
  }
  var picocolors_browser$1 = { exports: {} };
  var x$1 = String;
  var create$1 = function() {
    return { isColorSupported: false, reset: x$1, bold: x$1, dim: x$1, italic: x$1, underline: x$1, inverse: x$1, hidden: x$1, strikethrough: x$1, black: x$1, red: x$1, green: x$1, yellow: x$1, blue: x$1, magenta: x$1, cyan: x$1, white: x$1, gray: x$1, bgBlack: x$1, bgRed: x$1, bgGreen: x$1, bgYellow: x$1, bgBlue: x$1, bgMagenta: x$1, bgCyan: x$1, bgWhite: x$1 };
  };
  picocolors_browser$1.exports = create$1();
  picocolors_browser$1.exports.createColors = create$1;
  var picocolors_browserExports$1 = picocolors_browser$1.exports;
  var __viteBrowserExternal$2 = {};
  var __viteBrowserExternal$1$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
    __proto__: null,
    default: __viteBrowserExternal$2
  }, Symbol.toStringTag, { value: "Module" }));
  var require$$2$1 = /* @__PURE__ */ getAugmentedNamespace$1(__viteBrowserExternal$1$1);
  var pico$1 = picocolors_browserExports$1;
  var terminalHighlight$1$1 = require$$2$1;
  var CssSyntaxError$3$1 = class CssSyntaxError extends Error {
    constructor(message, line, column, source, file, plugin22) {
      super(message);
      this.name = "CssSyntaxError";
      this.reason = message;
      if (file) {
        this.file = file;
      }
      if (source) {
        this.source = source;
      }
      if (plugin22) {
        this.plugin = plugin22;
      }
      if (typeof line !== "undefined" && typeof column !== "undefined") {
        if (typeof line === "number") {
          this.line = line;
          this.column = column;
        } else {
          this.line = line.line;
          this.column = line.column;
          this.endLine = column.line;
          this.endColumn = column.column;
        }
      }
      this.setMessage();
      if (Error.captureStackTrace) {
        Error.captureStackTrace(this, CssSyntaxError);
      }
    }
    setMessage() {
      this.message = this.plugin ? this.plugin + ": " : "";
      this.message += this.file ? this.file : "<css input>";
      if (typeof this.line !== "undefined") {
        this.message += ":" + this.line + ":" + this.column;
      }
      this.message += ": " + this.reason;
    }
    showSourceCode(color) {
      if (!this.source) return "";
      let css = this.source;
      if (color == null) color = pico$1.isColorSupported;
      if (terminalHighlight$1$1) {
        if (color) css = terminalHighlight$1$1(css);
      }
      let lines = css.split(/\r?\n/);
      let start = Math.max(this.line - 3, 0);
      let end = Math.min(this.line + 2, lines.length);
      let maxWidth = String(end).length;
      let mark, aside;
      if (color) {
        let { bold, gray, red } = pico$1.createColors(true);
        mark = (text) => bold(red(text));
        aside = (text) => gray(text);
      } else {
        mark = aside = (str) => str;
      }
      return lines.slice(start, end).map((line, index2) => {
        let number = start + 1 + index2;
        let gutter = " " + (" " + number).slice(-maxWidth) + " | ";
        if (number === this.line) {
          let spacing = aside(gutter.replace(/\d/g, " ")) + line.slice(0, this.column - 1).replace(/[^\t]/g, " ");
          return mark(">") + aside(gutter) + line + "\n " + spacing + mark("^");
        }
        return " " + aside(gutter) + line;
      }).join("\n");
    }
    toString() {
      let code = this.showSourceCode();
      if (code) {
        code = "\n\n" + code + "\n";
      }
      return this.name + ": " + this.message + code;
    }
  };
  var cssSyntaxError$1 = CssSyntaxError$3$1;
  CssSyntaxError$3$1.default = CssSyntaxError$3$1;
  var symbols$1 = {};
  symbols$1.isClean = /* @__PURE__ */ Symbol("isClean");
  symbols$1.my = /* @__PURE__ */ Symbol("my");
  var DEFAULT_RAW$1 = {
    after: "\n",
    beforeClose: "\n",
    beforeComment: "\n",
    beforeDecl: "\n",
    beforeOpen: " ",
    beforeRule: "\n",
    colon: ": ",
    commentLeft: " ",
    commentRight: " ",
    emptyBody: "",
    indent: "    ",
    semicolon: false
  };
  function capitalize$1(str) {
    return str[0].toUpperCase() + str.slice(1);
  }
  var Stringifier$2$1 = class Stringifier {
    constructor(builder) {
      this.builder = builder;
    }
    atrule(node2, semicolon) {
      let name = "@" + node2.name;
      let params = node2.params ? this.rawValue(node2, "params") : "";
      if (typeof node2.raws.afterName !== "undefined") {
        name += node2.raws.afterName;
      } else if (params) {
        name += " ";
      }
      if (node2.nodes) {
        this.block(node2, name + params);
      } else {
        let end = (node2.raws.between || "") + (semicolon ? ";" : "");
        this.builder(name + params + end, node2);
      }
    }
    beforeAfter(node2, detect) {
      let value;
      if (node2.type === "decl") {
        value = this.raw(node2, null, "beforeDecl");
      } else if (node2.type === "comment") {
        value = this.raw(node2, null, "beforeComment");
      } else if (detect === "before") {
        value = this.raw(node2, null, "beforeRule");
      } else {
        value = this.raw(node2, null, "beforeClose");
      }
      let buf = node2.parent;
      let depth = 0;
      while (buf && buf.type !== "root") {
        depth += 1;
        buf = buf.parent;
      }
      if (value.includes("\n")) {
        let indent = this.raw(node2, null, "indent");
        if (indent.length) {
          for (let step = 0; step < depth; step++) value += indent;
        }
      }
      return value;
    }
    block(node2, start) {
      let between = this.raw(node2, "between", "beforeOpen");
      this.builder(start + between + "{", node2, "start");
      let after;
      if (node2.nodes && node2.nodes.length) {
        this.body(node2);
        after = this.raw(node2, "after");
      } else {
        after = this.raw(node2, "after", "emptyBody");
      }
      if (after) this.builder(after);
      this.builder("}", node2, "end");
    }
    body(node2) {
      let last = node2.nodes.length - 1;
      while (last > 0) {
        if (node2.nodes[last].type !== "comment") break;
        last -= 1;
      }
      let semicolon = this.raw(node2, "semicolon");
      for (let i2 = 0; i2 < node2.nodes.length; i2++) {
        let child = node2.nodes[i2];
        let before = this.raw(child, "before");
        if (before) this.builder(before);
        this.stringify(child, last !== i2 || semicolon);
      }
    }
    comment(node2) {
      let left = this.raw(node2, "left", "commentLeft");
      let right = this.raw(node2, "right", "commentRight");
      this.builder("/*" + left + node2.text + right + "*/", node2);
    }
    decl(node2, semicolon) {
      let between = this.raw(node2, "between", "colon");
      let string = node2.prop + between + this.rawValue(node2, "value");
      if (node2.important) {
        string += node2.raws.important || " !important";
      }
      if (semicolon) string += ";";
      this.builder(string, node2);
    }
    document(node2) {
      this.body(node2);
    }
    raw(node2, own, detect) {
      let value;
      if (!detect) detect = own;
      if (own) {
        value = node2.raws[own];
        if (typeof value !== "undefined") return value;
      }
      let parent = node2.parent;
      if (detect === "before") {
        if (!parent || parent.type === "root" && parent.first === node2) {
          return "";
        }
        if (parent && parent.type === "document") {
          return "";
        }
      }
      if (!parent) return DEFAULT_RAW$1[detect];
      let root2 = node2.root();
      if (!root2.rawCache) root2.rawCache = {};
      if (typeof root2.rawCache[detect] !== "undefined") {
        return root2.rawCache[detect];
      }
      if (detect === "before" || detect === "after") {
        return this.beforeAfter(node2, detect);
      } else {
        let method = "raw" + capitalize$1(detect);
        if (this[method]) {
          value = this[method](root2, node2);
        } else {
          root2.walk((i2) => {
            value = i2.raws[own];
            if (typeof value !== "undefined") return false;
          });
        }
      }
      if (typeof value === "undefined") value = DEFAULT_RAW$1[detect];
      root2.rawCache[detect] = value;
      return value;
    }
    rawBeforeClose(root2) {
      let value;
      root2.walk((i2) => {
        if (i2.nodes && i2.nodes.length > 0) {
          if (typeof i2.raws.after !== "undefined") {
            value = i2.raws.after;
            if (value.includes("\n")) {
              value = value.replace(/[^\n]+$/, "");
            }
            return false;
          }
        }
      });
      if (value) value = value.replace(/\S/g, "");
      return value;
    }
    rawBeforeComment(root2, node2) {
      let value;
      root2.walkComments((i2) => {
        if (typeof i2.raws.before !== "undefined") {
          value = i2.raws.before;
          if (value.includes("\n")) {
            value = value.replace(/[^\n]+$/, "");
          }
          return false;
        }
      });
      if (typeof value === "undefined") {
        value = this.raw(node2, null, "beforeDecl");
      } else if (value) {
        value = value.replace(/\S/g, "");
      }
      return value;
    }
    rawBeforeDecl(root2, node2) {
      let value;
      root2.walkDecls((i2) => {
        if (typeof i2.raws.before !== "undefined") {
          value = i2.raws.before;
          if (value.includes("\n")) {
            value = value.replace(/[^\n]+$/, "");
          }
          return false;
        }
      });
      if (typeof value === "undefined") {
        value = this.raw(node2, null, "beforeRule");
      } else if (value) {
        value = value.replace(/\S/g, "");
      }
      return value;
    }
    rawBeforeOpen(root2) {
      let value;
      root2.walk((i2) => {
        if (i2.type !== "decl") {
          value = i2.raws.between;
          if (typeof value !== "undefined") return false;
        }
      });
      return value;
    }
    rawBeforeRule(root2) {
      let value;
      root2.walk((i2) => {
        if (i2.nodes && (i2.parent !== root2 || root2.first !== i2)) {
          if (typeof i2.raws.before !== "undefined") {
            value = i2.raws.before;
            if (value.includes("\n")) {
              value = value.replace(/[^\n]+$/, "");
            }
            return false;
          }
        }
      });
      if (value) value = value.replace(/\S/g, "");
      return value;
    }
    rawColon(root2) {
      let value;
      root2.walkDecls((i2) => {
        if (typeof i2.raws.between !== "undefined") {
          value = i2.raws.between.replace(/[^\s:]/g, "");
          return false;
        }
      });
      return value;
    }
    rawEmptyBody(root2) {
      let value;
      root2.walk((i2) => {
        if (i2.nodes && i2.nodes.length === 0) {
          value = i2.raws.after;
          if (typeof value !== "undefined") return false;
        }
      });
      return value;
    }
    rawIndent(root2) {
      if (root2.raws.indent) return root2.raws.indent;
      let value;
      root2.walk((i2) => {
        let p = i2.parent;
        if (p && p !== root2 && p.parent && p.parent === root2) {
          if (typeof i2.raws.before !== "undefined") {
            let parts = i2.raws.before.split("\n");
            value = parts[parts.length - 1];
            value = value.replace(/\S/g, "");
            return false;
          }
        }
      });
      return value;
    }
    rawSemicolon(root2) {
      let value;
      root2.walk((i2) => {
        if (i2.nodes && i2.nodes.length && i2.last.type === "decl") {
          value = i2.raws.semicolon;
          if (typeof value !== "undefined") return false;
        }
      });
      return value;
    }
    rawValue(node2, prop) {
      let value = node2[prop];
      let raw = node2.raws[prop];
      if (raw && raw.value === value) {
        return raw.raw;
      }
      return value;
    }
    root(node2) {
      this.body(node2);
      if (node2.raws.after) this.builder(node2.raws.after);
    }
    rule(node2) {
      this.block(node2, this.rawValue(node2, "selector"));
      if (node2.raws.ownSemicolon) {
        this.builder(node2.raws.ownSemicolon, node2, "end");
      }
    }
    stringify(node2, semicolon) {
      if (!this[node2.type]) {
        throw new Error(
          "Unknown AST node type " + node2.type + ". Maybe you need to change PostCSS stringifier."
        );
      }
      this[node2.type](node2, semicolon);
    }
  };
  var stringifier$1 = Stringifier$2$1;
  Stringifier$2$1.default = Stringifier$2$1;
  var Stringifier$1$1 = stringifier$1;
  function stringify$4$1(node2, builder) {
    let str = new Stringifier$1$1(builder);
    str.stringify(node2);
  }
  var stringify_1$1 = stringify$4$1;
  stringify$4$1.default = stringify$4$1;
  var { isClean: isClean$2$1, my: my$2$1 } = symbols$1;
  var CssSyntaxError$2$1 = cssSyntaxError$1;
  var Stringifier2$1 = stringifier$1;
  var stringify$3$1 = stringify_1$1;
  function cloneNode$1(obj, parent) {
    let cloned = new obj.constructor();
    for (let i2 in obj) {
      if (!Object.prototype.hasOwnProperty.call(obj, i2)) {
        continue;
      }
      if (i2 === "proxyCache") continue;
      let value = obj[i2];
      let type = typeof value;
      if (i2 === "parent" && type === "object") {
        if (parent) cloned[i2] = parent;
      } else if (i2 === "source") {
        cloned[i2] = value;
      } else if (Array.isArray(value)) {
        cloned[i2] = value.map((j) => cloneNode$1(j, cloned));
      } else {
        if (type === "object" && value !== null) value = cloneNode$1(value);
        cloned[i2] = value;
      }
    }
    return cloned;
  }
  var Node$4$1 = class Node2 {
    constructor(defaults = {}) {
      this.raws = {};
      this[isClean$2$1] = false;
      this[my$2$1] = true;
      for (let name in defaults) {
        if (name === "nodes") {
          this.nodes = [];
          for (let node2 of defaults[name]) {
            if (typeof node2.clone === "function") {
              this.append(node2.clone());
            } else {
              this.append(node2);
            }
          }
        } else {
          this[name] = defaults[name];
        }
      }
    }
    addToError(error) {
      error.postcssNode = this;
      if (error.stack && this.source && /\n\s{4}at /.test(error.stack)) {
        let s2 = this.source;
        error.stack = error.stack.replace(
          /\n\s{4}at /,
          `$&${s2.input.from}:${s2.start.line}:${s2.start.column}$&`
        );
      }
      return error;
    }
    after(add) {
      this.parent.insertAfter(this, add);
      return this;
    }
    assign(overrides = {}) {
      for (let name in overrides) {
        this[name] = overrides[name];
      }
      return this;
    }
    before(add) {
      this.parent.insertBefore(this, add);
      return this;
    }
    cleanRaws(keepBetween) {
      delete this.raws.before;
      delete this.raws.after;
      if (!keepBetween) delete this.raws.between;
    }
    clone(overrides = {}) {
      let cloned = cloneNode$1(this);
      for (let name in overrides) {
        cloned[name] = overrides[name];
      }
      return cloned;
    }
    cloneAfter(overrides = {}) {
      let cloned = this.clone(overrides);
      this.parent.insertAfter(this, cloned);
      return cloned;
    }
    cloneBefore(overrides = {}) {
      let cloned = this.clone(overrides);
      this.parent.insertBefore(this, cloned);
      return cloned;
    }
    error(message, opts = {}) {
      if (this.source) {
        let { end, start } = this.rangeBy(opts);
        return this.source.input.error(
          message,
          { column: start.column, line: start.line },
          { column: end.column, line: end.line },
          opts
        );
      }
      return new CssSyntaxError$2$1(message);
    }
    getProxyProcessor() {
      return {
        get(node2, prop) {
          if (prop === "proxyOf") {
            return node2;
          } else if (prop === "root") {
            return () => node2.root().toProxy();
          } else {
            return node2[prop];
          }
        },
        set(node2, prop, value) {
          if (node2[prop] === value) return true;
          node2[prop] = value;
          if (prop === "prop" || prop === "value" || prop === "name" || prop === "params" || prop === "important" || /* c8 ignore next */
          prop === "text") {
            node2.markDirty();
          }
          return true;
        }
      };
    }
    markDirty() {
      if (this[isClean$2$1]) {
        this[isClean$2$1] = false;
        let next = this;
        while (next = next.parent) {
          next[isClean$2$1] = false;
        }
      }
    }
    next() {
      if (!this.parent) return void 0;
      let index2 = this.parent.index(this);
      return this.parent.nodes[index2 + 1];
    }
    positionBy(opts, stringRepresentation) {
      let pos = this.source.start;
      if (opts.index) {
        pos = this.positionInside(opts.index, stringRepresentation);
      } else if (opts.word) {
        stringRepresentation = this.toString();
        let index2 = stringRepresentation.indexOf(opts.word);
        if (index2 !== -1) pos = this.positionInside(index2, stringRepresentation);
      }
      return pos;
    }
    positionInside(index2, stringRepresentation) {
      let string = stringRepresentation || this.toString();
      let column = this.source.start.column;
      let line = this.source.start.line;
      for (let i2 = 0; i2 < index2; i2++) {
        if (string[i2] === "\n") {
          column = 1;
          line += 1;
        } else {
          column += 1;
        }
      }
      return { column, line };
    }
    prev() {
      if (!this.parent) return void 0;
      let index2 = this.parent.index(this);
      return this.parent.nodes[index2 - 1];
    }
    rangeBy(opts) {
      let start = {
        column: this.source.start.column,
        line: this.source.start.line
      };
      let end = this.source.end ? {
        column: this.source.end.column + 1,
        line: this.source.end.line
      } : {
        column: start.column + 1,
        line: start.line
      };
      if (opts.word) {
        let stringRepresentation = this.toString();
        let index2 = stringRepresentation.indexOf(opts.word);
        if (index2 !== -1) {
          start = this.positionInside(index2, stringRepresentation);
          end = this.positionInside(index2 + opts.word.length, stringRepresentation);
        }
      } else {
        if (opts.start) {
          start = {
            column: opts.start.column,
            line: opts.start.line
          };
        } else if (opts.index) {
          start = this.positionInside(opts.index);
        }
        if (opts.end) {
          end = {
            column: opts.end.column,
            line: opts.end.line
          };
        } else if (typeof opts.endIndex === "number") {
          end = this.positionInside(opts.endIndex);
        } else if (opts.index) {
          end = this.positionInside(opts.index + 1);
        }
      }
      if (end.line < start.line || end.line === start.line && end.column <= start.column) {
        end = { column: start.column + 1, line: start.line };
      }
      return { end, start };
    }
    raw(prop, defaultType) {
      let str = new Stringifier2$1();
      return str.raw(this, prop, defaultType);
    }
    remove() {
      if (this.parent) {
        this.parent.removeChild(this);
      }
      this.parent = void 0;
      return this;
    }
    replaceWith(...nodes) {
      if (this.parent) {
        let bookmark = this;
        let foundSelf = false;
        for (let node2 of nodes) {
          if (node2 === this) {
            foundSelf = true;
          } else if (foundSelf) {
            this.parent.insertAfter(bookmark, node2);
            bookmark = node2;
          } else {
            this.parent.insertBefore(bookmark, node2);
          }
        }
        if (!foundSelf) {
          this.remove();
        }
      }
      return this;
    }
    root() {
      let result2 = this;
      while (result2.parent && result2.parent.type !== "document") {
        result2 = result2.parent;
      }
      return result2;
    }
    toJSON(_, inputs) {
      let fixed = {};
      let emitInputs = inputs == null;
      inputs = inputs || /* @__PURE__ */ new Map();
      let inputsNextIndex = 0;
      for (let name in this) {
        if (!Object.prototype.hasOwnProperty.call(this, name)) {
          continue;
        }
        if (name === "parent" || name === "proxyCache") continue;
        let value = this[name];
        if (Array.isArray(value)) {
          fixed[name] = value.map((i2) => {
            if (typeof i2 === "object" && i2.toJSON) {
              return i2.toJSON(null, inputs);
            } else {
              return i2;
            }
          });
        } else if (typeof value === "object" && value.toJSON) {
          fixed[name] = value.toJSON(null, inputs);
        } else if (name === "source") {
          let inputId = inputs.get(value.input);
          if (inputId == null) {
            inputId = inputsNextIndex;
            inputs.set(value.input, inputsNextIndex);
            inputsNextIndex++;
          }
          fixed[name] = {
            end: value.end,
            inputId,
            start: value.start
          };
        } else {
          fixed[name] = value;
        }
      }
      if (emitInputs) {
        fixed.inputs = [...inputs.keys()].map((input2) => input2.toJSON());
      }
      return fixed;
    }
    toProxy() {
      if (!this.proxyCache) {
        this.proxyCache = new Proxy(this, this.getProxyProcessor());
      }
      return this.proxyCache;
    }
    toString(stringifier2 = stringify$3$1) {
      if (stringifier2.stringify) stringifier2 = stringifier2.stringify;
      let result2 = "";
      stringifier2(this, (i2) => {
        result2 += i2;
      });
      return result2;
    }
    warn(result2, text, opts) {
      let data = { node: this };
      for (let i2 in opts) data[i2] = opts[i2];
      return result2.warn(text, data);
    }
    get proxyOf() {
      return this;
    }
  };
  var node$1 = Node$4$1;
  Node$4$1.default = Node$4$1;
  var Node$3$1 = node$1;
  var Declaration$4$1 = class Declaration extends Node$3$1 {
    constructor(defaults) {
      if (defaults && typeof defaults.value !== "undefined" && typeof defaults.value !== "string") {
        defaults = { ...defaults, value: String(defaults.value) };
      }
      super(defaults);
      this.type = "decl";
    }
    get variable() {
      return this.prop.startsWith("--") || this.prop[0] === "$";
    }
  };
  var declaration$1 = Declaration$4$1;
  Declaration$4$1.default = Declaration$4$1;
  var urlAlphabet$1 = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
  var customAlphabet$1 = (alphabet, defaultSize = 21) => {
    return (size = defaultSize) => {
      let id = "";
      let i2 = size;
      while (i2--) {
        id += alphabet[Math.random() * alphabet.length | 0];
      }
      return id;
    };
  };
  var nanoid$1$1 = (size = 21) => {
    let id = "";
    let i2 = size;
    while (i2--) {
      id += urlAlphabet$1[Math.random() * 64 | 0];
    }
    return id;
  };
  var nonSecure$1 = { nanoid: nanoid$1$1, customAlphabet: customAlphabet$1 };
  var { SourceMapConsumer: SourceMapConsumer$2$1, SourceMapGenerator: SourceMapGenerator$2$1 } = require$$2$1;
  var { existsSync: existsSync$1, readFileSync: readFileSync$1 } = require$$2$1;
  var { dirname: dirname$1$1, join: join$1 } = require$$2$1;
  function fromBase64$1(str) {
    if (Buffer) {
      return Buffer.from(str, "base64").toString();
    } else {
      return window.atob(str);
    }
  }
  var PreviousMap$2$1 = class PreviousMap {
    constructor(css, opts) {
      if (opts.map === false) return;
      this.loadAnnotation(css);
      this.inline = this.startWith(this.annotation, "data:");
      let prev = opts.map ? opts.map.prev : void 0;
      let text = this.loadMap(opts.from, prev);
      if (!this.mapFile && opts.from) {
        this.mapFile = opts.from;
      }
      if (this.mapFile) this.root = dirname$1$1(this.mapFile);
      if (text) this.text = text;
    }
    consumer() {
      if (!this.consumerCache) {
        this.consumerCache = new SourceMapConsumer$2$1(this.text);
      }
      return this.consumerCache;
    }
    decodeInline(text) {
      let baseCharsetUri = /^data:application\/json;charset=utf-?8;base64,/;
      let baseUri = /^data:application\/json;base64,/;
      let charsetUri = /^data:application\/json;charset=utf-?8,/;
      let uri = /^data:application\/json,/;
      if (charsetUri.test(text) || uri.test(text)) {
        return decodeURIComponent(text.substr(RegExp.lastMatch.length));
      }
      if (baseCharsetUri.test(text) || baseUri.test(text)) {
        return fromBase64$1(text.substr(RegExp.lastMatch.length));
      }
      let encoding = text.match(/data:application\/json;([^,]+),/)[1];
      throw new Error("Unsupported source map encoding " + encoding);
    }
    getAnnotationURL(sourceMapString) {
      return sourceMapString.replace(/^\/\*\s*# sourceMappingURL=/, "").trim();
    }
    isMap(map) {
      if (typeof map !== "object") return false;
      return typeof map.mappings === "string" || typeof map._mappings === "string" || Array.isArray(map.sections);
    }
    loadAnnotation(css) {
      let comments = css.match(/\/\*\s*# sourceMappingURL=/gm);
      if (!comments) return;
      let start = css.lastIndexOf(comments.pop());
      let end = css.indexOf("*/", start);
      if (start > -1 && end > -1) {
        this.annotation = this.getAnnotationURL(css.substring(start, end));
      }
    }
    loadFile(path) {
      this.root = dirname$1$1(path);
      if (existsSync$1(path)) {
        this.mapFile = path;
        return readFileSync$1(path, "utf-8").toString().trim();
      }
    }
    loadMap(file, prev) {
      if (prev === false) return false;
      if (prev) {
        if (typeof prev === "string") {
          return prev;
        } else if (typeof prev === "function") {
          let prevPath = prev(file);
          if (prevPath) {
            let map = this.loadFile(prevPath);
            if (!map) {
              throw new Error(
                "Unable to load previous source map: " + prevPath.toString()
              );
            }
            return map;
          }
        } else if (prev instanceof SourceMapConsumer$2$1) {
          return SourceMapGenerator$2$1.fromSourceMap(prev).toString();
        } else if (prev instanceof SourceMapGenerator$2$1) {
          return prev.toString();
        } else if (this.isMap(prev)) {
          return JSON.stringify(prev);
        } else {
          throw new Error(
            "Unsupported previous source map format: " + prev.toString()
          );
        }
      } else if (this.inline) {
        return this.decodeInline(this.annotation);
      } else if (this.annotation) {
        let map = this.annotation;
        if (file) map = join$1(dirname$1$1(file), map);
        return this.loadFile(map);
      }
    }
    startWith(string, start) {
      if (!string) return false;
      return string.substr(0, start.length) === start;
    }
    withContent() {
      return !!(this.consumer().sourcesContent && this.consumer().sourcesContent.length > 0);
    }
  };
  var previousMap$1 = PreviousMap$2$1;
  PreviousMap$2$1.default = PreviousMap$2$1;
  var { SourceMapConsumer: SourceMapConsumer$1$1, SourceMapGenerator: SourceMapGenerator$1$1 } = require$$2$1;
  var { fileURLToPath: fileURLToPath$1, pathToFileURL: pathToFileURL$1$1 } = require$$2$1;
  var { isAbsolute: isAbsolute$1, resolve: resolve$1$1 } = require$$2$1;
  var { nanoid: nanoid$2 } = nonSecure$1;
  var terminalHighlight$2 = require$$2$1;
  var CssSyntaxError$1$1 = cssSyntaxError$1;
  var PreviousMap$1$1 = previousMap$1;
  var fromOffsetCache$1 = /* @__PURE__ */ Symbol("fromOffsetCache");
  var sourceMapAvailable$1$1 = Boolean(SourceMapConsumer$1$1 && SourceMapGenerator$1$1);
  var pathAvailable$1$1 = Boolean(resolve$1$1 && isAbsolute$1);
  var Input$4$1 = class Input {
    constructor(css, opts = {}) {
      if (css === null || typeof css === "undefined" || typeof css === "object" && !css.toString) {
        throw new Error(`PostCSS received ${css} instead of CSS string`);
      }
      this.css = css.toString();
      if (this.css[0] === "\uFEFF" || this.css[0] === "\uFFFE") {
        this.hasBOM = true;
        this.css = this.css.slice(1);
      } else {
        this.hasBOM = false;
      }
      if (opts.from) {
        if (!pathAvailable$1$1 || /^\w+:\/\//.test(opts.from) || isAbsolute$1(opts.from)) {
          this.file = opts.from;
        } else {
          this.file = resolve$1$1(opts.from);
        }
      }
      if (pathAvailable$1$1 && sourceMapAvailable$1$1) {
        let map = new PreviousMap$1$1(this.css, opts);
        if (map.text) {
          this.map = map;
          let file = map.consumer().file;
          if (!this.file && file) this.file = this.mapResolve(file);
        }
      }
      if (!this.file) {
        this.id = "<input css " + nanoid$2(6) + ">";
      }
      if (this.map) this.map.file = this.from;
    }
    error(message, line, column, opts = {}) {
      let result2, endLine, endColumn;
      if (line && typeof line === "object") {
        let start = line;
        let end = column;
        if (typeof start.offset === "number") {
          let pos = this.fromOffset(start.offset);
          line = pos.line;
          column = pos.col;
        } else {
          line = start.line;
          column = start.column;
        }
        if (typeof end.offset === "number") {
          let pos = this.fromOffset(end.offset);
          endLine = pos.line;
          endColumn = pos.col;
        } else {
          endLine = end.line;
          endColumn = end.column;
        }
      } else if (!column) {
        let pos = this.fromOffset(line);
        line = pos.line;
        column = pos.col;
      }
      let origin = this.origin(line, column, endLine, endColumn);
      if (origin) {
        result2 = new CssSyntaxError$1$1(
          message,
          origin.endLine === void 0 ? origin.line : { column: origin.column, line: origin.line },
          origin.endLine === void 0 ? origin.column : { column: origin.endColumn, line: origin.endLine },
          origin.source,
          origin.file,
          opts.plugin
        );
      } else {
        result2 = new CssSyntaxError$1$1(
          message,
          endLine === void 0 ? line : { column, line },
          endLine === void 0 ? column : { column: endColumn, line: endLine },
          this.css,
          this.file,
          opts.plugin
        );
      }
      result2.input = { column, endColumn, endLine, line, source: this.css };
      if (this.file) {
        if (pathToFileURL$1$1) {
          result2.input.url = pathToFileURL$1$1(this.file).toString();
        }
        result2.input.file = this.file;
      }
      return result2;
    }
    fromOffset(offset) {
      let lastLine, lineToIndex;
      if (!this[fromOffsetCache$1]) {
        let lines = this.css.split("\n");
        lineToIndex = new Array(lines.length);
        let prevIndex = 0;
        for (let i2 = 0, l2 = lines.length; i2 < l2; i2++) {
          lineToIndex[i2] = prevIndex;
          prevIndex += lines[i2].length + 1;
        }
        this[fromOffsetCache$1] = lineToIndex;
      } else {
        lineToIndex = this[fromOffsetCache$1];
      }
      lastLine = lineToIndex[lineToIndex.length - 1];
      let min = 0;
      if (offset >= lastLine) {
        min = lineToIndex.length - 1;
      } else {
        let max = lineToIndex.length - 2;
        let mid;
        while (min < max) {
          mid = min + (max - min >> 1);
          if (offset < lineToIndex[mid]) {
            max = mid - 1;
          } else if (offset >= lineToIndex[mid + 1]) {
            min = mid + 1;
          } else {
            min = mid;
            break;
          }
        }
      }
      return {
        col: offset - lineToIndex[min] + 1,
        line: min + 1
      };
    }
    mapResolve(file) {
      if (/^\w+:\/\//.test(file)) {
        return file;
      }
      return resolve$1$1(this.map.consumer().sourceRoot || this.map.root || ".", file);
    }
    origin(line, column, endLine, endColumn) {
      if (!this.map) return false;
      let consumer = this.map.consumer();
      let from = consumer.originalPositionFor({ column, line });
      if (!from.source) return false;
      let to;
      if (typeof endLine === "number") {
        to = consumer.originalPositionFor({ column: endColumn, line: endLine });
      }
      let fromUrl;
      if (isAbsolute$1(from.source)) {
        fromUrl = pathToFileURL$1$1(from.source);
      } else {
        fromUrl = new URL(
          from.source,
          this.map.consumer().sourceRoot || pathToFileURL$1$1(this.map.mapFile)
        );
      }
      let result2 = {
        column: from.column,
        endColumn: to && to.column,
        endLine: to && to.line,
        line: from.line,
        url: fromUrl.toString()
      };
      if (fromUrl.protocol === "file:") {
        if (fileURLToPath$1) {
          result2.file = fileURLToPath$1(fromUrl);
        } else {
          throw new Error(`file: protocol is not available in this PostCSS build`);
        }
      }
      let source = consumer.sourceContentFor(from.source);
      if (source) result2.source = source;
      return result2;
    }
    toJSON() {
      let json = {};
      for (let name of ["hasBOM", "css", "file", "id"]) {
        if (this[name] != null) {
          json[name] = this[name];
        }
      }
      if (this.map) {
        json.map = { ...this.map };
        if (json.map.consumerCache) {
          json.map.consumerCache = void 0;
        }
      }
      return json;
    }
    get from() {
      return this.file || this.id;
    }
  };
  var input$1 = Input$4$1;
  Input$4$1.default = Input$4$1;
  if (terminalHighlight$2 && terminalHighlight$2.registerInput) {
    terminalHighlight$2.registerInput(Input$4$1);
  }
  var { SourceMapConsumer: SourceMapConsumer$3, SourceMapGenerator: SourceMapGenerator$3 } = require$$2$1;
  var { dirname: dirname$2, relative: relative$1, resolve: resolve$2, sep: sep$1 } = require$$2$1;
  var { pathToFileURL: pathToFileURL$2 } = require$$2$1;
  var Input$3$1 = input$1;
  var sourceMapAvailable$2 = Boolean(SourceMapConsumer$3 && SourceMapGenerator$3);
  var pathAvailable$2 = Boolean(dirname$2 && resolve$2 && relative$1 && sep$1);
  var MapGenerator$2$1 = class MapGenerator {
    constructor(stringify22, root2, opts, cssString) {
      this.stringify = stringify22;
      this.mapOpts = opts.map || {};
      this.root = root2;
      this.opts = opts;
      this.css = cssString;
      this.originalCSS = cssString;
      this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute;
      this.memoizedFileURLs = /* @__PURE__ */ new Map();
      this.memoizedPaths = /* @__PURE__ */ new Map();
      this.memoizedURLs = /* @__PURE__ */ new Map();
    }
    addAnnotation() {
      let content;
      if (this.isInline()) {
        content = "data:application/json;base64," + this.toBase64(this.map.toString());
      } else if (typeof this.mapOpts.annotation === "string") {
        content = this.mapOpts.annotation;
      } else if (typeof this.mapOpts.annotation === "function") {
        content = this.mapOpts.annotation(this.opts.to, this.root);
      } else {
        content = this.outputFile() + ".map";
      }
      let eol = "\n";
      if (this.css.includes("\r\n")) eol = "\r\n";
      this.css += eol + "/*# sourceMappingURL=" + content + " */";
    }
    applyPrevMaps() {
      for (let prev of this.previous()) {
        let from = this.toUrl(this.path(prev.file));
        let root2 = prev.root || dirname$2(prev.file);
        let map;
        if (this.mapOpts.sourcesContent === false) {
          map = new SourceMapConsumer$3(prev.text);
          if (map.sourcesContent) {
            map.sourcesContent = null;
          }
        } else {
          map = prev.consumer();
        }
        this.map.applySourceMap(map, from, this.toUrl(this.path(root2)));
      }
    }
    clearAnnotation() {
      if (this.mapOpts.annotation === false) return;
      if (this.root) {
        let node2;
        for (let i2 = this.root.nodes.length - 1; i2 >= 0; i2--) {
          node2 = this.root.nodes[i2];
          if (node2.type !== "comment") continue;
          if (node2.text.indexOf("# sourceMappingURL=") === 0) {
            this.root.removeChild(i2);
          }
        }
      } else if (this.css) {
        this.css = this.css.replace(/\n*?\/\*#[\S\s]*?\*\/$/gm, "");
      }
    }
    generate() {
      this.clearAnnotation();
      if (pathAvailable$2 && sourceMapAvailable$2 && this.isMap()) {
        return this.generateMap();
      } else {
        let result2 = "";
        this.stringify(this.root, (i2) => {
          result2 += i2;
        });
        return [result2];
      }
    }
    generateMap() {
      if (this.root) {
        this.generateString();
      } else if (this.previous().length === 1) {
        let prev = this.previous()[0].consumer();
        prev.file = this.outputFile();
        this.map = SourceMapGenerator$3.fromSourceMap(prev, {
          ignoreInvalidMapping: true
        });
      } else {
        this.map = new SourceMapGenerator$3({
          file: this.outputFile(),
          ignoreInvalidMapping: true
        });
        this.map.addMapping({
          generated: { column: 0, line: 1 },
          original: { column: 0, line: 1 },
          source: this.opts.from ? this.toUrl(this.path(this.opts.from)) : "<no source>"
        });
      }
      if (this.isSourcesContent()) this.setSourcesContent();
      if (this.root && this.previous().length > 0) this.applyPrevMaps();
      if (this.isAnnotation()) this.addAnnotation();
      if (this.isInline()) {
        return [this.css];
      } else {
        return [this.css, this.map];
      }
    }
    generateString() {
      this.css = "";
      this.map = new SourceMapGenerator$3({
        file: this.outputFile(),
        ignoreInvalidMapping: true
      });
      let line = 1;
      let column = 1;
      let noSource = "<no source>";
      let mapping = {
        generated: { column: 0, line: 0 },
        original: { column: 0, line: 0 },
        source: ""
      };
      let lines, last;
      this.stringify(this.root, (str, node2, type) => {
        this.css += str;
        if (node2 && type !== "end") {
          mapping.generated.line = line;
          mapping.generated.column = column - 1;
          if (node2.source && node2.source.start) {
            mapping.source = this.sourcePath(node2);
            mapping.original.line = node2.source.start.line;
            mapping.original.column = node2.source.start.column - 1;
            this.map.addMapping(mapping);
          } else {
            mapping.source = noSource;
            mapping.original.line = 1;
            mapping.original.column = 0;
            this.map.addMapping(mapping);
          }
        }
        lines = str.match(/\n/g);
        if (lines) {
          line += lines.length;
          last = str.lastIndexOf("\n");
          column = str.length - last;
        } else {
          column += str.length;
        }
        if (node2 && type !== "start") {
          let p = node2.parent || { raws: {} };
          let childless = node2.type === "decl" || node2.type === "atrule" && !node2.nodes;
          if (!childless || node2 !== p.last || p.raws.semicolon) {
            if (node2.source && node2.source.end) {
              mapping.source = this.sourcePath(node2);
              mapping.original.line = node2.source.end.line;
              mapping.original.column = node2.source.end.column - 1;
              mapping.generated.line = line;
              mapping.generated.column = column - 2;
              this.map.addMapping(mapping);
            } else {
              mapping.source = noSource;
              mapping.original.line = 1;
              mapping.original.column = 0;
              mapping.generated.line = line;
              mapping.generated.column = column - 1;
              this.map.addMapping(mapping);
            }
          }
        }
      });
    }
    isAnnotation() {
      if (this.isInline()) {
        return true;
      }
      if (typeof this.mapOpts.annotation !== "undefined") {
        return this.mapOpts.annotation;
      }
      if (this.previous().length) {
        return this.previous().some((i2) => i2.annotation);
      }
      return true;
    }
    isInline() {
      if (typeof this.mapOpts.inline !== "undefined") {
        return this.mapOpts.inline;
      }
      let annotation = this.mapOpts.annotation;
      if (typeof annotation !== "undefined" && annotation !== true) {
        return false;
      }
      if (this.previous().length) {
        return this.previous().some((i2) => i2.inline);
      }
      return true;
    }
    isMap() {
      if (typeof this.opts.map !== "undefined") {
        return !!this.opts.map;
      }
      return this.previous().length > 0;
    }
    isSourcesContent() {
      if (typeof this.mapOpts.sourcesContent !== "undefined") {
        return this.mapOpts.sourcesContent;
      }
      if (this.previous().length) {
        return this.previous().some((i2) => i2.withContent());
      }
      return true;
    }
    outputFile() {
      if (this.opts.to) {
        return this.path(this.opts.to);
      } else if (this.opts.from) {
        return this.path(this.opts.from);
      } else {
        return "to.css";
      }
    }
    path(file) {
      if (this.mapOpts.absolute) return file;
      if (file.charCodeAt(0) === 60) return file;
      if (/^\w+:\/\//.test(file)) return file;
      let cached = this.memoizedPaths.get(file);
      if (cached) return cached;
      let from = this.opts.to ? dirname$2(this.opts.to) : ".";
      if (typeof this.mapOpts.annotation === "string") {
        from = dirname$2(resolve$2(from, this.mapOpts.annotation));
      }
      let path = relative$1(from, file);
      this.memoizedPaths.set(file, path);
      return path;
    }
    previous() {
      if (!this.previousMaps) {
        this.previousMaps = [];
        if (this.root) {
          this.root.walk((node2) => {
            if (node2.source && node2.source.input.map) {
              let map = node2.source.input.map;
              if (!this.previousMaps.includes(map)) {
                this.previousMaps.push(map);
              }
            }
          });
        } else {
          let input2 = new Input$3$1(this.originalCSS, this.opts);
          if (input2.map) this.previousMaps.push(input2.map);
        }
      }
      return this.previousMaps;
    }
    setSourcesContent() {
      let already = {};
      if (this.root) {
        this.root.walk((node2) => {
          if (node2.source) {
            let from = node2.source.input.from;
            if (from && !already[from]) {
              already[from] = true;
              let fromUrl = this.usesFileUrls ? this.toFileUrl(from) : this.toUrl(this.path(from));
              this.map.setSourceContent(fromUrl, node2.source.input.css);
            }
          }
        });
      } else if (this.css) {
        let from = this.opts.from ? this.toUrl(this.path(this.opts.from)) : "<no source>";
        this.map.setSourceContent(from, this.css);
      }
    }
    sourcePath(node2) {
      if (this.mapOpts.from) {
        return this.toUrl(this.mapOpts.from);
      } else if (this.usesFileUrls) {
        return this.toFileUrl(node2.source.input.from);
      } else {
        return this.toUrl(this.path(node2.source.input.from));
      }
    }
    toBase64(str) {
      if (Buffer) {
        return Buffer.from(str).toString("base64");
      } else {
        return window.btoa(unescape(encodeURIComponent(str)));
      }
    }
    toFileUrl(path) {
      let cached = this.memoizedFileURLs.get(path);
      if (cached) return cached;
      if (pathToFileURL$2) {
        let fileURL = pathToFileURL$2(path).toString();
        this.memoizedFileURLs.set(path, fileURL);
        return fileURL;
      } else {
        throw new Error(
          "`map.absolute` option is not available in this PostCSS build"
        );
      }
    }
    toUrl(path) {
      let cached = this.memoizedURLs.get(path);
      if (cached) return cached;
      if (sep$1 === "\\") {
        path = path.replace(/\\/g, "/");
      }
      let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent);
      this.memoizedURLs.set(path, url);
      return url;
    }
  };
  var mapGenerator$1 = MapGenerator$2$1;
  var Node$2$1 = node$1;
  var Comment$4$1 = class Comment extends Node$2$1 {
    constructor(defaults) {
      super(defaults);
      this.type = "comment";
    }
  };
  var comment$1 = Comment$4$1;
  Comment$4$1.default = Comment$4$1;
  var { isClean: isClean$1$1, my: my$1$1 } = symbols$1;
  var Declaration$3$1 = declaration$1;
  var Comment$3$1 = comment$1;
  var Node$1$1 = node$1;
  var parse$4$1;
  var Rule$4$1;
  var AtRule$4$1;
  var Root$6$1;
  function cleanSource$1(nodes) {
    return nodes.map((i2) => {
      if (i2.nodes) i2.nodes = cleanSource$1(i2.nodes);
      delete i2.source;
      return i2;
    });
  }
  function markDirtyUp$1(node2) {
    node2[isClean$1$1] = false;
    if (node2.proxyOf.nodes) {
      for (let i2 of node2.proxyOf.nodes) {
        markDirtyUp$1(i2);
      }
    }
  }
  var Container$7$1 = class Container extends Node$1$1 {
    append(...children) {
      for (let child of children) {
        let nodes = this.normalize(child, this.last);
        for (let node2 of nodes) this.proxyOf.nodes.push(node2);
      }
      this.markDirty();
      return this;
    }
    cleanRaws(keepBetween) {
      super.cleanRaws(keepBetween);
      if (this.nodes) {
        for (let node2 of this.nodes) node2.cleanRaws(keepBetween);
      }
    }
    each(callback) {
      if (!this.proxyOf.nodes) return void 0;
      let iterator = this.getIterator();
      let index2, result2;
      while (this.indexes[iterator] < this.proxyOf.nodes.length) {
        index2 = this.indexes[iterator];
        result2 = callback(this.proxyOf.nodes[index2], index2);
        if (result2 === false) break;
        this.indexes[iterator] += 1;
      }
      delete this.indexes[iterator];
      return result2;
    }
    every(condition) {
      return this.nodes.every(condition);
    }
    getIterator() {
      if (!this.lastEach) this.lastEach = 0;
      if (!this.indexes) this.indexes = {};
      this.lastEach += 1;
      let iterator = this.lastEach;
      this.indexes[iterator] = 0;
      return iterator;
    }
    getProxyProcessor() {
      return {
        get(node2, prop) {
          if (prop === "proxyOf") {
            return node2;
          } else if (!node2[prop]) {
            return node2[prop];
          } else if (prop === "each" || typeof prop === "string" && prop.startsWith("walk")) {
            return (...args) => {
              return node2[prop](
                ...args.map((i2) => {
                  if (typeof i2 === "function") {
                    return (child, index2) => i2(child.toProxy(), index2);
                  } else {
                    return i2;
                  }
                })
              );
            };
          } else if (prop === "every" || prop === "some") {
            return (cb) => {
              return node2[prop](
                (child, ...other) => cb(child.toProxy(), ...other)
              );
            };
          } else if (prop === "root") {
            return () => node2.root().toProxy();
          } else if (prop === "nodes") {
            return node2.nodes.map((i2) => i2.toProxy());
          } else if (prop === "first" || prop === "last") {
            return node2[prop].toProxy();
          } else {
            return node2[prop];
          }
        },
        set(node2, prop, value) {
          if (node2[prop] === value) return true;
          node2[prop] = value;
          if (prop === "name" || prop === "params" || prop === "selector") {
            node2.markDirty();
          }
          return true;
        }
      };
    }
    index(child) {
      if (typeof child === "number") return child;
      if (child.proxyOf) child = child.proxyOf;
      return this.proxyOf.nodes.indexOf(child);
    }
    insertAfter(exist, add) {
      let existIndex = this.index(exist);
      let nodes = this.normalize(add, this.proxyOf.nodes[existIndex]).reverse();
      existIndex = this.index(exist);
      for (let node2 of nodes) this.proxyOf.nodes.splice(existIndex + 1, 0, node2);
      let index2;
      for (let id in this.indexes) {
        index2 = this.indexes[id];
        if (existIndex < index2) {
          this.indexes[id] = index2 + nodes.length;
        }
      }
      this.markDirty();
      return this;
    }
    insertBefore(exist, add) {
      let existIndex = this.index(exist);
      let type = existIndex === 0 ? "prepend" : false;
      let nodes = this.normalize(add, this.proxyOf.nodes[existIndex], type).reverse();
      existIndex = this.index(exist);
      for (let node2 of nodes) this.proxyOf.nodes.splice(existIndex, 0, node2);
      let index2;
      for (let id in this.indexes) {
        index2 = this.indexes[id];
        if (existIndex <= index2) {
          this.indexes[id] = index2 + nodes.length;
        }
      }
      this.markDirty();
      return this;
    }
    normalize(nodes, sample) {
      if (typeof nodes === "string") {
        nodes = cleanSource$1(parse$4$1(nodes).nodes);
      } else if (typeof nodes === "undefined") {
        nodes = [];
      } else if (Array.isArray(nodes)) {
        nodes = nodes.slice(0);
        for (let i2 of nodes) {
          if (i2.parent) i2.parent.removeChild(i2, "ignore");
        }
      } else if (nodes.type === "root" && this.type !== "document") {
        nodes = nodes.nodes.slice(0);
        for (let i2 of nodes) {
          if (i2.parent) i2.parent.removeChild(i2, "ignore");
        }
      } else if (nodes.type) {
        nodes = [nodes];
      } else if (nodes.prop) {
        if (typeof nodes.value === "undefined") {
          throw new Error("Value field is missed in node creation");
        } else if (typeof nodes.value !== "string") {
          nodes.value = String(nodes.value);
        }
        nodes = [new Declaration$3$1(nodes)];
      } else if (nodes.selector) {
        nodes = [new Rule$4$1(nodes)];
      } else if (nodes.name) {
        nodes = [new AtRule$4$1(nodes)];
      } else if (nodes.text) {
        nodes = [new Comment$3$1(nodes)];
      } else {
        throw new Error("Unknown node type in node creation");
      }
      let processed = nodes.map((i2) => {
        if (!i2[my$1$1]) Container.rebuild(i2);
        i2 = i2.proxyOf;
        if (i2.parent) i2.parent.removeChild(i2);
        if (i2[isClean$1$1]) markDirtyUp$1(i2);
        if (typeof i2.raws.before === "undefined") {
          if (sample && typeof sample.raws.before !== "undefined") {
            i2.raws.before = sample.raws.before.replace(/\S/g, "");
          }
        }
        i2.parent = this.proxyOf;
        return i2;
      });
      return processed;
    }
    prepend(...children) {
      children = children.reverse();
      for (let child of children) {
        let nodes = this.normalize(child, this.first, "prepend").reverse();
        for (let node2 of nodes) this.proxyOf.nodes.unshift(node2);
        for (let id in this.indexes) {
          this.indexes[id] = this.indexes[id] + nodes.length;
        }
      }
      this.markDirty();
      return this;
    }
    push(child) {
      child.parent = this;
      this.proxyOf.nodes.push(child);
      return this;
    }
    removeAll() {
      for (let node2 of this.proxyOf.nodes) node2.parent = void 0;
      this.proxyOf.nodes = [];
      this.markDirty();
      return this;
    }
    removeChild(child) {
      child = this.index(child);
      this.proxyOf.nodes[child].parent = void 0;
      this.proxyOf.nodes.splice(child, 1);
      let index2;
      for (let id in this.indexes) {
        index2 = this.indexes[id];
        if (index2 >= child) {
          this.indexes[id] = index2 - 1;
        }
      }
      this.markDirty();
      return this;
    }
    replaceValues(pattern, opts, callback) {
      if (!callback) {
        callback = opts;
        opts = {};
      }
      this.walkDecls((decl) => {
        if (opts.props && !opts.props.includes(decl.prop)) return;
        if (opts.fast && !decl.value.includes(opts.fast)) return;
        decl.value = decl.value.replace(pattern, callback);
      });
      this.markDirty();
      return this;
    }
    some(condition) {
      return this.nodes.some(condition);
    }
    walk(callback) {
      return this.each((child, i2) => {
        let result2;
        try {
          result2 = callback(child, i2);
        } catch (e2) {
          throw child.addToError(e2);
        }
        if (result2 !== false && child.walk) {
          result2 = child.walk(callback);
        }
        return result2;
      });
    }
    walkAtRules(name, callback) {
      if (!callback) {
        callback = name;
        return this.walk((child, i2) => {
          if (child.type === "atrule") {
            return callback(child, i2);
          }
        });
      }
      if (name instanceof RegExp) {
        return this.walk((child, i2) => {
          if (child.type === "atrule" && name.test(child.name)) {
            return callback(child, i2);
          }
        });
      }
      return this.walk((child, i2) => {
        if (child.type === "atrule" && child.name === name) {
          return callback(child, i2);
        }
      });
    }
    walkComments(callback) {
      return this.walk((child, i2) => {
        if (child.type === "comment") {
          return callback(child, i2);
        }
      });
    }
    walkDecls(prop, callback) {
      if (!callback) {
        callback = prop;
        return this.walk((child, i2) => {
          if (child.type === "decl") {
            return callback(child, i2);
          }
        });
      }
      if (prop instanceof RegExp) {
        return this.walk((child, i2) => {
          if (child.type === "decl" && prop.test(child.prop)) {
            return callback(child, i2);
          }
        });
      }
      return this.walk((child, i2) => {
        if (child.type === "decl" && child.prop === prop) {
          return callback(child, i2);
        }
      });
    }
    walkRules(selector, callback) {
      if (!callback) {
        callback = selector;
        return this.walk((child, i2) => {
          if (child.type === "rule") {
            return callback(child, i2);
          }
        });
      }
      if (selector instanceof RegExp) {
        return this.walk((child, i2) => {
          if (child.type === "rule" && selector.test(child.selector)) {
            return callback(child, i2);
          }
        });
      }
      return this.walk((child, i2) => {
        if (child.type === "rule" && child.selector === selector) {
          return callback(child, i2);
        }
      });
    }
    get first() {
      if (!this.proxyOf.nodes) return void 0;
      return this.proxyOf.nodes[0];
    }
    get last() {
      if (!this.proxyOf.nodes) return void 0;
      return this.proxyOf.nodes[this.proxyOf.nodes.length - 1];
    }
  };
  Container$7$1.registerParse = (dependant) => {
    parse$4$1 = dependant;
  };
  Container$7$1.registerRule = (dependant) => {
    Rule$4$1 = dependant;
  };
  Container$7$1.registerAtRule = (dependant) => {
    AtRule$4$1 = dependant;
  };
  Container$7$1.registerRoot = (dependant) => {
    Root$6$1 = dependant;
  };
  var container$1 = Container$7$1;
  Container$7$1.default = Container$7$1;
  Container$7$1.rebuild = (node2) => {
    if (node2.type === "atrule") {
      Object.setPrototypeOf(node2, AtRule$4$1.prototype);
    } else if (node2.type === "rule") {
      Object.setPrototypeOf(node2, Rule$4$1.prototype);
    } else if (node2.type === "decl") {
      Object.setPrototypeOf(node2, Declaration$3$1.prototype);
    } else if (node2.type === "comment") {
      Object.setPrototypeOf(node2, Comment$3$1.prototype);
    } else if (node2.type === "root") {
      Object.setPrototypeOf(node2, Root$6$1.prototype);
    }
    node2[my$1$1] = true;
    if (node2.nodes) {
      node2.nodes.forEach((child) => {
        Container$7$1.rebuild(child);
      });
    }
  };
  var Container$6$1 = container$1;
  var LazyResult$4$1;
  var Processor$3$1;
  var Document$3$1 = class Document2 extends Container$6$1 {
    constructor(defaults) {
      super({ type: "document", ...defaults });
      if (!this.nodes) {
        this.nodes = [];
      }
    }
    toResult(opts = {}) {
      let lazy = new LazyResult$4$1(new Processor$3$1(), this, opts);
      return lazy.stringify();
    }
  };
  Document$3$1.registerLazyResult = (dependant) => {
    LazyResult$4$1 = dependant;
  };
  Document$3$1.registerProcessor = (dependant) => {
    Processor$3$1 = dependant;
  };
  var document$1$1 = Document$3$1;
  Document$3$1.default = Document$3$1;
  var printed$1 = {};
  var warnOnce$2$1 = function warnOnce(message) {
    if (printed$1[message]) return;
    printed$1[message] = true;
    if (typeof console !== "undefined" && console.warn) {
      console.warn(message);
    }
  };
  var Warning$2$1 = class Warning {
    constructor(text, opts = {}) {
      this.type = "warning";
      this.text = text;
      if (opts.node && opts.node.source) {
        let range = opts.node.rangeBy(opts);
        this.line = range.start.line;
        this.column = range.start.column;
        this.endLine = range.end.line;
        this.endColumn = range.end.column;
      }
      for (let opt in opts) this[opt] = opts[opt];
    }
    toString() {
      if (this.node) {
        return this.node.error(this.text, {
          index: this.index,
          plugin: this.plugin,
          word: this.word
        }).message;
      }
      if (this.plugin) {
        return this.plugin + ": " + this.text;
      }
      return this.text;
    }
  };
  var warning$1 = Warning$2$1;
  Warning$2$1.default = Warning$2$1;
  var Warning$1$1 = warning$1;
  var Result$3$1 = class Result {
    constructor(processor2, root2, opts) {
      this.processor = processor2;
      this.messages = [];
      this.root = root2;
      this.opts = opts;
      this.css = void 0;
      this.map = void 0;
    }
    toString() {
      return this.css;
    }
    warn(text, opts = {}) {
      if (!opts.plugin) {
        if (this.lastPlugin && this.lastPlugin.postcssPlugin) {
          opts.plugin = this.lastPlugin.postcssPlugin;
        }
      }
      let warning2 = new Warning$1$1(text, opts);
      this.messages.push(warning2);
      return warning2;
    }
    warnings() {
      return this.messages.filter((i2) => i2.type === "warning");
    }
    get content() {
      return this.css;
    }
  };
  var result$1 = Result$3$1;
  Result$3$1.default = Result$3$1;
  var SINGLE_QUOTE$1 = "'".charCodeAt(0);
  var DOUBLE_QUOTE$1 = '"'.charCodeAt(0);
  var BACKSLASH$1 = "\\".charCodeAt(0);
  var SLASH$1 = "/".charCodeAt(0);
  var NEWLINE$1 = "\n".charCodeAt(0);
  var SPACE$1 = " ".charCodeAt(0);
  var FEED$1 = "\f".charCodeAt(0);
  var TAB$1 = "	".charCodeAt(0);
  var CR$1 = "\r".charCodeAt(0);
  var OPEN_SQUARE$1 = "[".charCodeAt(0);
  var CLOSE_SQUARE$1 = "]".charCodeAt(0);
  var OPEN_PARENTHESES$1 = "(".charCodeAt(0);
  var CLOSE_PARENTHESES$1 = ")".charCodeAt(0);
  var OPEN_CURLY$1 = "{".charCodeAt(0);
  var CLOSE_CURLY$1 = "}".charCodeAt(0);
  var SEMICOLON$1 = ";".charCodeAt(0);
  var ASTERISK$1 = "*".charCodeAt(0);
  var COLON$1 = ":".charCodeAt(0);
  var AT$1 = "@".charCodeAt(0);
  var RE_AT_END$1 = /[\t\n\f\r "#'()/;[\\\]{}]/g;
  var RE_WORD_END$1 = /[\t\n\f\r !"#'():;@[\\\]{}]|\/(?=\*)/g;
  var RE_BAD_BRACKET$1 = /.[\r\n"'(/\\]/;
  var RE_HEX_ESCAPE$1 = /[\da-f]/i;
  var tokenize$1 = function tokenizer(input2, options = {}) {
    let css = input2.css.valueOf();
    let ignore = options.ignoreErrors;
    let code, next, quote, content, escape;
    let escaped, escapePos, prev, n2, currentToken;
    let length = css.length;
    let pos = 0;
    let buffer = [];
    let returned = [];
    function position() {
      return pos;
    }
    function unclosed(what) {
      throw input2.error("Unclosed " + what, pos);
    }
    function endOfFile() {
      return returned.length === 0 && pos >= length;
    }
    function nextToken(opts) {
      if (returned.length) return returned.pop();
      if (pos >= length) return;
      let ignoreUnclosed = opts ? opts.ignoreUnclosed : false;
      code = css.charCodeAt(pos);
      switch (code) {
        case NEWLINE$1:
        case SPACE$1:
        case TAB$1:
        case CR$1:
        case FEED$1: {
          next = pos;
          do {
            next += 1;
            code = css.charCodeAt(next);
          } while (code === SPACE$1 || code === NEWLINE$1 || code === TAB$1 || code === CR$1 || code === FEED$1);
          currentToken = ["space", css.slice(pos, next)];
          pos = next - 1;
          break;
        }
        case OPEN_SQUARE$1:
        case CLOSE_SQUARE$1:
        case OPEN_CURLY$1:
        case CLOSE_CURLY$1:
        case COLON$1:
        case SEMICOLON$1:
        case CLOSE_PARENTHESES$1: {
          let controlChar = String.fromCharCode(code);
          currentToken = [controlChar, controlChar, pos];
          break;
        }
        case OPEN_PARENTHESES$1: {
          prev = buffer.length ? buffer.pop()[1] : "";
          n2 = css.charCodeAt(pos + 1);
          if (prev === "url" && n2 !== SINGLE_QUOTE$1 && n2 !== DOUBLE_QUOTE$1 && n2 !== SPACE$1 && n2 !== NEWLINE$1 && n2 !== TAB$1 && n2 !== FEED$1 && n2 !== CR$1) {
            next = pos;
            do {
              escaped = false;
              next = css.indexOf(")", next + 1);
              if (next === -1) {
                if (ignore || ignoreUnclosed) {
                  next = pos;
                  break;
                } else {
                  unclosed("bracket");
                }
              }
              escapePos = next;
              while (css.charCodeAt(escapePos - 1) === BACKSLASH$1) {
                escapePos -= 1;
                escaped = !escaped;
              }
            } while (escaped);
            currentToken = ["brackets", css.slice(pos, next + 1), pos, next];
            pos = next;
          } else {
            next = css.indexOf(")", pos + 1);
            content = css.slice(pos, next + 1);
            if (next === -1 || RE_BAD_BRACKET$1.test(content)) {
              currentToken = ["(", "(", pos];
            } else {
              currentToken = ["brackets", content, pos, next];
              pos = next;
            }
          }
          break;
        }
        case SINGLE_QUOTE$1:
        case DOUBLE_QUOTE$1: {
          quote = code === SINGLE_QUOTE$1 ? "'" : '"';
          next = pos;
          do {
            escaped = false;
            next = css.indexOf(quote, next + 1);
            if (next === -1) {
              if (ignore || ignoreUnclosed) {
                next = pos + 1;
                break;
              } else {
                unclosed("string");
              }
            }
            escapePos = next;
            while (css.charCodeAt(escapePos - 1) === BACKSLASH$1) {
              escapePos -= 1;
              escaped = !escaped;
            }
          } while (escaped);
          currentToken = ["string", css.slice(pos, next + 1), pos, next];
          pos = next;
          break;
        }
        case AT$1: {
          RE_AT_END$1.lastIndex = pos + 1;
          RE_AT_END$1.test(css);
          if (RE_AT_END$1.lastIndex === 0) {
            next = css.length - 1;
          } else {
            next = RE_AT_END$1.lastIndex - 2;
          }
          currentToken = ["at-word", css.slice(pos, next + 1), pos, next];
          pos = next;
          break;
        }
        case BACKSLASH$1: {
          next = pos;
          escape = true;
          while (css.charCodeAt(next + 1) === BACKSLASH$1) {
            next += 1;
            escape = !escape;
          }
          code = css.charCodeAt(next + 1);
          if (escape && code !== SLASH$1 && code !== SPACE$1 && code !== NEWLINE$1 && code !== TAB$1 && code !== CR$1 && code !== FEED$1) {
            next += 1;
            if (RE_HEX_ESCAPE$1.test(css.charAt(next))) {
              while (RE_HEX_ESCAPE$1.test(css.charAt(next + 1))) {
                next += 1;
              }
              if (css.charCodeAt(next + 1) === SPACE$1) {
                next += 1;
              }
            }
          }
          currentToken = ["word", css.slice(pos, next + 1), pos, next];
          pos = next;
          break;
        }
        default: {
          if (code === SLASH$1 && css.charCodeAt(pos + 1) === ASTERISK$1) {
            next = css.indexOf("*/", pos + 2) + 1;
            if (next === 0) {
              if (ignore || ignoreUnclosed) {
                next = css.length;
              } else {
                unclosed("comment");
              }
            }
            currentToken = ["comment", css.slice(pos, next + 1), pos, next];
            pos = next;
          } else {
            RE_WORD_END$1.lastIndex = pos + 1;
            RE_WORD_END$1.test(css);
            if (RE_WORD_END$1.lastIndex === 0) {
              next = css.length - 1;
            } else {
              next = RE_WORD_END$1.lastIndex - 2;
            }
            currentToken = ["word", css.slice(pos, next + 1), pos, next];
            buffer.push(currentToken);
            pos = next;
          }
          break;
        }
      }
      pos++;
      return currentToken;
    }
    function back(token) {
      returned.push(token);
    }
    return {
      back,
      endOfFile,
      nextToken,
      position
    };
  };
  var Container$5$1 = container$1;
  var AtRule$3$1 = class AtRule extends Container$5$1 {
    constructor(defaults) {
      super(defaults);
      this.type = "atrule";
    }
    append(...children) {
      if (!this.proxyOf.nodes) this.nodes = [];
      return super.append(...children);
    }
    prepend(...children) {
      if (!this.proxyOf.nodes) this.nodes = [];
      return super.prepend(...children);
    }
  };
  var atRule$1 = AtRule$3$1;
  AtRule$3$1.default = AtRule$3$1;
  Container$5$1.registerAtRule(AtRule$3$1);
  var Container$4$1 = container$1;
  var LazyResult$3$1;
  var Processor$2$1;
  var Root$5$1 = class Root extends Container$4$1 {
    constructor(defaults) {
      super(defaults);
      this.type = "root";
      if (!this.nodes) this.nodes = [];
    }
    normalize(child, sample, type) {
      let nodes = super.normalize(child);
      if (sample) {
        if (type === "prepend") {
          if (this.nodes.length > 1) {
            sample.raws.before = this.nodes[1].raws.before;
          } else {
            delete sample.raws.before;
          }
        } else if (this.first !== sample) {
          for (let node2 of nodes) {
            node2.raws.before = sample.raws.before;
          }
        }
      }
      return nodes;
    }
    removeChild(child, ignore) {
      let index2 = this.index(child);
      if (!ignore && index2 === 0 && this.nodes.length > 1) {
        this.nodes[1].raws.before = this.nodes[index2].raws.before;
      }
      return super.removeChild(child);
    }
    toResult(opts = {}) {
      let lazy = new LazyResult$3$1(new Processor$2$1(), this, opts);
      return lazy.stringify();
    }
  };
  Root$5$1.registerLazyResult = (dependant) => {
    LazyResult$3$1 = dependant;
  };
  Root$5$1.registerProcessor = (dependant) => {
    Processor$2$1 = dependant;
  };
  var root$1 = Root$5$1;
  Root$5$1.default = Root$5$1;
  Container$4$1.registerRoot(Root$5$1);
  var list$2$1 = {
    comma(string) {
      return list$2$1.split(string, [","], true);
    },
    space(string) {
      let spaces = [" ", "\n", "	"];
      return list$2$1.split(string, spaces);
    },
    split(string, separators, last) {
      let array = [];
      let current = "";
      let split = false;
      let func = 0;
      let inQuote = false;
      let prevQuote = "";
      let escape = false;
      for (let letter of string) {
        if (escape) {
          escape = false;
        } else if (letter === "\\") {
          escape = true;
        } else if (inQuote) {
          if (letter === prevQuote) {
            inQuote = false;
          }
        } else if (letter === '"' || letter === "'") {
          inQuote = true;
          prevQuote = letter;
        } else if (letter === "(") {
          func += 1;
        } else if (letter === ")") {
          if (func > 0) func -= 1;
        } else if (func === 0) {
          if (separators.includes(letter)) split = true;
        }
        if (split) {
          if (current !== "") array.push(current.trim());
          current = "";
          split = false;
        } else {
          current += letter;
        }
      }
      if (last || current !== "") array.push(current.trim());
      return array;
    }
  };
  var list_1$1 = list$2$1;
  list$2$1.default = list$2$1;
  var Container$3$1 = container$1;
  var list$1$1 = list_1$1;
  var Rule$3$1 = class Rule extends Container$3$1 {
    constructor(defaults) {
      super(defaults);
      this.type = "rule";
      if (!this.nodes) this.nodes = [];
    }
    get selectors() {
      return list$1$1.comma(this.selector);
    }
    set selectors(values) {
      let match = this.selector ? this.selector.match(/,\s*/) : null;
      let sep2 = match ? match[0] : "," + this.raw("between", "beforeOpen");
      this.selector = values.join(sep2);
    }
  };
  var rule$1 = Rule$3$1;
  Rule$3$1.default = Rule$3$1;
  Container$3$1.registerRule(Rule$3$1);
  var Declaration$2$1 = declaration$1;
  var tokenizer2$1 = tokenize$1;
  var Comment$2$1 = comment$1;
  var AtRule$2$1 = atRule$1;
  var Root$4$1 = root$1;
  var Rule$2$1 = rule$1;
  var SAFE_COMMENT_NEIGHBOR$1 = {
    empty: true,
    space: true
  };
  function findLastWithPosition$1(tokens) {
    for (let i2 = tokens.length - 1; i2 >= 0; i2--) {
      let token = tokens[i2];
      let pos = token[3] || token[2];
      if (pos) return pos;
    }
  }
  var Parser$1$1 = class Parser {
    constructor(input2) {
      this.input = input2;
      this.root = new Root$4$1();
      this.current = this.root;
      this.spaces = "";
      this.semicolon = false;
      this.createTokenizer();
      this.root.source = { input: input2, start: { column: 1, line: 1, offset: 0 } };
    }
    atrule(token) {
      let node2 = new AtRule$2$1();
      node2.name = token[1].slice(1);
      if (node2.name === "") {
        this.unnamedAtrule(node2, token);
      }
      this.init(node2, token[2]);
      let type;
      let prev;
      let shift;
      let last = false;
      let open = false;
      let params = [];
      let brackets = [];
      while (!this.tokenizer.endOfFile()) {
        token = this.tokenizer.nextToken();
        type = token[0];
        if (type === "(" || type === "[") {
          brackets.push(type === "(" ? ")" : "]");
        } else if (type === "{" && brackets.length > 0) {
          brackets.push("}");
        } else if (type === brackets[brackets.length - 1]) {
          brackets.pop();
        }
        if (brackets.length === 0) {
          if (type === ";") {
            node2.source.end = this.getPosition(token[2]);
            node2.source.end.offset++;
            this.semicolon = true;
            break;
          } else if (type === "{") {
            open = true;
            break;
          } else if (type === "}") {
            if (params.length > 0) {
              shift = params.length - 1;
              prev = params[shift];
              while (prev && prev[0] === "space") {
                prev = params[--shift];
              }
              if (prev) {
                node2.source.end = this.getPosition(prev[3] || prev[2]);
                node2.source.end.offset++;
              }
            }
            this.end(token);
            break;
          } else {
            params.push(token);
          }
        } else {
          params.push(token);
        }
        if (this.tokenizer.endOfFile()) {
          last = true;
          break;
        }
      }
      node2.raws.between = this.spacesAndCommentsFromEnd(params);
      if (params.length) {
        node2.raws.afterName = this.spacesAndCommentsFromStart(params);
        this.raw(node2, "params", params);
        if (last) {
          token = params[params.length - 1];
          node2.source.end = this.getPosition(token[3] || token[2]);
          node2.source.end.offset++;
          this.spaces = node2.raws.between;
          node2.raws.between = "";
        }
      } else {
        node2.raws.afterName = "";
        node2.params = "";
      }
      if (open) {
        node2.nodes = [];
        this.current = node2;
      }
    }
    checkMissedSemicolon(tokens) {
      let colon = this.colon(tokens);
      if (colon === false) return;
      let founded = 0;
      let token;
      for (let j = colon - 1; j >= 0; j--) {
        token = tokens[j];
        if (token[0] !== "space") {
          founded += 1;
          if (founded === 2) break;
        }
      }
      throw this.input.error(
        "Missed semicolon",
        token[0] === "word" ? token[3] + 1 : token[2]
      );
    }
    colon(tokens) {
      let brackets = 0;
      let token, type, prev;
      for (let [i2, element] of tokens.entries()) {
        token = element;
        type = token[0];
        if (type === "(") {
          brackets += 1;
        }
        if (type === ")") {
          brackets -= 1;
        }
        if (brackets === 0 && type === ":") {
          if (!prev) {
            this.doubleColon(token);
          } else if (prev[0] === "word" && prev[1] === "progid") {
            continue;
          } else {
            return i2;
          }
        }
        prev = token;
      }
      return false;
    }
    comment(token) {
      let node2 = new Comment$2$1();
      this.init(node2, token[2]);
      node2.source.end = this.getPosition(token[3] || token[2]);
      node2.source.end.offset++;
      let text = token[1].slice(2, -2);
      if (/^\s*$/.test(text)) {
        node2.text = "";
        node2.raws.left = text;
        node2.raws.right = "";
      } else {
        let match = text.match(/^(\s*)([^]*\S)(\s*)$/);
        node2.text = match[2];
        node2.raws.left = match[1];
        node2.raws.right = match[3];
      }
    }
    createTokenizer() {
      this.tokenizer = tokenizer2$1(this.input);
    }
    decl(tokens, customProperty) {
      let node2 = new Declaration$2$1();
      this.init(node2, tokens[0][2]);
      let last = tokens[tokens.length - 1];
      if (last[0] === ";") {
        this.semicolon = true;
        tokens.pop();
      }
      node2.source.end = this.getPosition(
        last[3] || last[2] || findLastWithPosition$1(tokens)
      );
      node2.source.end.offset++;
      while (tokens[0][0] !== "word") {
        if (tokens.length === 1) this.unknownWord(tokens);
        node2.raws.before += tokens.shift()[1];
      }
      node2.source.start = this.getPosition(tokens[0][2]);
      node2.prop = "";
      while (tokens.length) {
        let type = tokens[0][0];
        if (type === ":" || type === "space" || type === "comment") {
          break;
        }
        node2.prop += tokens.shift()[1];
      }
      node2.raws.between = "";
      let token;
      while (tokens.length) {
        token = tokens.shift();
        if (token[0] === ":") {
          node2.raws.between += token[1];
          break;
        } else {
          if (token[0] === "word" && /\w/.test(token[1])) {
            this.unknownWord([token]);
          }
          node2.raws.between += token[1];
        }
      }
      if (node2.prop[0] === "_" || node2.prop[0] === "*") {
        node2.raws.before += node2.prop[0];
        node2.prop = node2.prop.slice(1);
      }
      let firstSpaces = [];
      let next;
      while (tokens.length) {
        next = tokens[0][0];
        if (next !== "space" && next !== "comment") break;
        firstSpaces.push(tokens.shift());
      }
      this.precheckMissedSemicolon(tokens);
      for (let i2 = tokens.length - 1; i2 >= 0; i2--) {
        token = tokens[i2];
        if (token[1].toLowerCase() === "!important") {
          node2.important = true;
          let string = this.stringFrom(tokens, i2);
          string = this.spacesFromEnd(tokens) + string;
          if (string !== " !important") node2.raws.important = string;
          break;
        } else if (token[1].toLowerCase() === "important") {
          let cache = tokens.slice(0);
          let str = "";
          for (let j = i2; j > 0; j--) {
            let type = cache[j][0];
            if (str.trim().indexOf("!") === 0 && type !== "space") {
              break;
            }
            str = cache.pop()[1] + str;
          }
          if (str.trim().indexOf("!") === 0) {
            node2.important = true;
            node2.raws.important = str;
            tokens = cache;
          }
        }
        if (token[0] !== "space" && token[0] !== "comment") {
          break;
        }
      }
      let hasWord = tokens.some((i2) => i2[0] !== "space" && i2[0] !== "comment");
      if (hasWord) {
        node2.raws.between += firstSpaces.map((i2) => i2[1]).join("");
        firstSpaces = [];
      }
      this.raw(node2, "value", firstSpaces.concat(tokens), customProperty);
      if (node2.value.includes(":") && !customProperty) {
        this.checkMissedSemicolon(tokens);
      }
    }
    doubleColon(token) {
      throw this.input.error(
        "Double colon",
        { offset: token[2] },
        { offset: token[2] + token[1].length }
      );
    }
    emptyRule(token) {
      let node2 = new Rule$2$1();
      this.init(node2, token[2]);
      node2.selector = "";
      node2.raws.between = "";
      this.current = node2;
    }
    end(token) {
      if (this.current.nodes && this.current.nodes.length) {
        this.current.raws.semicolon = this.semicolon;
      }
      this.semicolon = false;
      this.current.raws.after = (this.current.raws.after || "") + this.spaces;
      this.spaces = "";
      if (this.current.parent) {
        this.current.source.end = this.getPosition(token[2]);
        this.current.source.end.offset++;
        this.current = this.current.parent;
      } else {
        this.unexpectedClose(token);
      }
    }
    endFile() {
      if (this.current.parent) this.unclosedBlock();
      if (this.current.nodes && this.current.nodes.length) {
        this.current.raws.semicolon = this.semicolon;
      }
      this.current.raws.after = (this.current.raws.after || "") + this.spaces;
      this.root.source.end = this.getPosition(this.tokenizer.position());
    }
    freeSemicolon(token) {
      this.spaces += token[1];
      if (this.current.nodes) {
        let prev = this.current.nodes[this.current.nodes.length - 1];
        if (prev && prev.type === "rule" && !prev.raws.ownSemicolon) {
          prev.raws.ownSemicolon = this.spaces;
          this.spaces = "";
        }
      }
    }
    // Helpers
    getPosition(offset) {
      let pos = this.input.fromOffset(offset);
      return {
        column: pos.col,
        line: pos.line,
        offset
      };
    }
    init(node2, offset) {
      this.current.push(node2);
      node2.source = {
        input: this.input,
        start: this.getPosition(offset)
      };
      node2.raws.before = this.spaces;
      this.spaces = "";
      if (node2.type !== "comment") this.semicolon = false;
    }
    other(start) {
      let end = false;
      let type = null;
      let colon = false;
      let bracket = null;
      let brackets = [];
      let customProperty = start[1].startsWith("--");
      let tokens = [];
      let token = start;
      while (token) {
        type = token[0];
        tokens.push(token);
        if (type === "(" || type === "[") {
          if (!bracket) bracket = token;
          brackets.push(type === "(" ? ")" : "]");
        } else if (customProperty && colon && type === "{") {
          if (!bracket) bracket = token;
          brackets.push("}");
        } else if (brackets.length === 0) {
          if (type === ";") {
            if (colon) {
              this.decl(tokens, customProperty);
              return;
            } else {
              break;
            }
          } else if (type === "{") {
            this.rule(tokens);
            return;
          } else if (type === "}") {
            this.tokenizer.back(tokens.pop());
            end = true;
            break;
          } else if (type === ":") {
            colon = true;
          }
        } else if (type === brackets[brackets.length - 1]) {
          brackets.pop();
          if (brackets.length === 0) bracket = null;
        }
        token = this.tokenizer.nextToken();
      }
      if (this.tokenizer.endOfFile()) end = true;
      if (brackets.length > 0) this.unclosedBracket(bracket);
      if (end && colon) {
        if (!customProperty) {
          while (tokens.length) {
            token = tokens[tokens.length - 1][0];
            if (token !== "space" && token !== "comment") break;
            this.tokenizer.back(tokens.pop());
          }
        }
        this.decl(tokens, customProperty);
      } else {
        this.unknownWord(tokens);
      }
    }
    parse() {
      let token;
      while (!this.tokenizer.endOfFile()) {
        token = this.tokenizer.nextToken();
        switch (token[0]) {
          case "space":
            this.spaces += token[1];
            break;
          case ";":
            this.freeSemicolon(token);
            break;
          case "}":
            this.end(token);
            break;
          case "comment":
            this.comment(token);
            break;
          case "at-word":
            this.atrule(token);
            break;
          case "{":
            this.emptyRule(token);
            break;
          default:
            this.other(token);
            break;
        }
      }
      this.endFile();
    }
    precheckMissedSemicolon() {
    }
    raw(node2, prop, tokens, customProperty) {
      let token, type;
      let length = tokens.length;
      let value = "";
      let clean = true;
      let next, prev;
      for (let i2 = 0; i2 < length; i2 += 1) {
        token = tokens[i2];
        type = token[0];
        if (type === "space" && i2 === length - 1 && !customProperty) {
          clean = false;
        } else if (type === "comment") {
          prev = tokens[i2 - 1] ? tokens[i2 - 1][0] : "empty";
          next = tokens[i2 + 1] ? tokens[i2 + 1][0] : "empty";
          if (!SAFE_COMMENT_NEIGHBOR$1[prev] && !SAFE_COMMENT_NEIGHBOR$1[next]) {
            if (value.slice(-1) === ",") {
              clean = false;
            } else {
              value += token[1];
            }
          } else {
            clean = false;
          }
        } else {
          value += token[1];
        }
      }
      if (!clean) {
        let raw = tokens.reduce((all, i2) => all + i2[1], "");
        node2.raws[prop] = { raw, value };
      }
      node2[prop] = value;
    }
    rule(tokens) {
      tokens.pop();
      let node2 = new Rule$2$1();
      this.init(node2, tokens[0][2]);
      node2.raws.between = this.spacesAndCommentsFromEnd(tokens);
      this.raw(node2, "selector", tokens);
      this.current = node2;
    }
    spacesAndCommentsFromEnd(tokens) {
      let lastTokenType;
      let spaces = "";
      while (tokens.length) {
        lastTokenType = tokens[tokens.length - 1][0];
        if (lastTokenType !== "space" && lastTokenType !== "comment") break;
        spaces = tokens.pop()[1] + spaces;
      }
      return spaces;
    }
    // Errors
    spacesAndCommentsFromStart(tokens) {
      let next;
      let spaces = "";
      while (tokens.length) {
        next = tokens[0][0];
        if (next !== "space" && next !== "comment") break;
        spaces += tokens.shift()[1];
      }
      return spaces;
    }
    spacesFromEnd(tokens) {
      let lastTokenType;
      let spaces = "";
      while (tokens.length) {
        lastTokenType = tokens[tokens.length - 1][0];
        if (lastTokenType !== "space") break;
        spaces = tokens.pop()[1] + spaces;
      }
      return spaces;
    }
    stringFrom(tokens, from) {
      let result2 = "";
      for (let i2 = from; i2 < tokens.length; i2++) {
        result2 += tokens[i2][1];
      }
      tokens.splice(from, tokens.length - from);
      return result2;
    }
    unclosedBlock() {
      let pos = this.current.source.start;
      throw this.input.error("Unclosed block", pos.line, pos.column);
    }
    unclosedBracket(bracket) {
      throw this.input.error(
        "Unclosed bracket",
        { offset: bracket[2] },
        { offset: bracket[2] + 1 }
      );
    }
    unexpectedClose(token) {
      throw this.input.error(
        "Unexpected }",
        { offset: token[2] },
        { offset: token[2] + 1 }
      );
    }
    unknownWord(tokens) {
      throw this.input.error(
        "Unknown word",
        { offset: tokens[0][2] },
        { offset: tokens[0][2] + tokens[0][1].length }
      );
    }
    unnamedAtrule(node2, token) {
      throw this.input.error(
        "At-rule without name",
        { offset: token[2] },
        { offset: token[2] + token[1].length }
      );
    }
  };
  var parser$1 = Parser$1$1;
  var Container$2$1 = container$1;
  var Parser2$1 = parser$1;
  var Input$2$1 = input$1;
  function parse$3$1(css, opts) {
    let input2 = new Input$2$1(css, opts);
    let parser2 = new Parser2$1(input2);
    try {
      parser2.parse();
    } catch (e2) {
      if (true) {
        if (e2.name === "CssSyntaxError" && opts && opts.from) {
          if (/\.scss$/i.test(opts.from)) {
            e2.message += "\nYou tried to parse SCSS with the standard CSS parser; try again with the postcss-scss parser";
          } else if (/\.sass/i.test(opts.from)) {
            e2.message += "\nYou tried to parse Sass with the standard CSS parser; try again with the postcss-sass parser";
          } else if (/\.less$/i.test(opts.from)) {
            e2.message += "\nYou tried to parse Less with the standard CSS parser; try again with the postcss-less parser";
          }
        }
      }
      throw e2;
    }
    return parser2.root;
  }
  var parse_1$1 = parse$3$1;
  parse$3$1.default = parse$3$1;
  Container$2$1.registerParse(parse$3$1);
  var { isClean: isClean$3, my: my$3 } = symbols$1;
  var MapGenerator$1$1 = mapGenerator$1;
  var stringify$2$1 = stringify_1$1;
  var Container$1$1 = container$1;
  var Document$2$1 = document$1$1;
  var warnOnce$1$1 = warnOnce$2$1;
  var Result$2$1 = result$1;
  var parse$2$1 = parse_1$1;
  var Root$3$1 = root$1;
  var TYPE_TO_CLASS_NAME$1 = {
    atrule: "AtRule",
    comment: "Comment",
    decl: "Declaration",
    document: "Document",
    root: "Root",
    rule: "Rule"
  };
  var PLUGIN_PROPS$1 = {
    AtRule: true,
    AtRuleExit: true,
    Comment: true,
    CommentExit: true,
    Declaration: true,
    DeclarationExit: true,
    Document: true,
    DocumentExit: true,
    Once: true,
    OnceExit: true,
    postcssPlugin: true,
    prepare: true,
    Root: true,
    RootExit: true,
    Rule: true,
    RuleExit: true
  };
  var NOT_VISITORS$1 = {
    Once: true,
    postcssPlugin: true,
    prepare: true
  };
  var CHILDREN$1 = 0;
  function isPromise$1(obj) {
    return typeof obj === "object" && typeof obj.then === "function";
  }
  function getEvents$1(node2) {
    let key = false;
    let type = TYPE_TO_CLASS_NAME$1[node2.type];
    if (node2.type === "decl") {
      key = node2.prop.toLowerCase();
    } else if (node2.type === "atrule") {
      key = node2.name.toLowerCase();
    }
    if (key && node2.append) {
      return [
        type,
        type + "-" + key,
        CHILDREN$1,
        type + "Exit",
        type + "Exit-" + key
      ];
    } else if (key) {
      return [type, type + "-" + key, type + "Exit", type + "Exit-" + key];
    } else if (node2.append) {
      return [type, CHILDREN$1, type + "Exit"];
    } else {
      return [type, type + "Exit"];
    }
  }
  function toStack$1(node2) {
    let events;
    if (node2.type === "document") {
      events = ["Document", CHILDREN$1, "DocumentExit"];
    } else if (node2.type === "root") {
      events = ["Root", CHILDREN$1, "RootExit"];
    } else {
      events = getEvents$1(node2);
    }
    return {
      eventIndex: 0,
      events,
      iterator: 0,
      node: node2,
      visitorIndex: 0,
      visitors: []
    };
  }
  function cleanMarks$1(node2) {
    node2[isClean$3] = false;
    if (node2.nodes) node2.nodes.forEach((i2) => cleanMarks$1(i2));
    return node2;
  }
  var postcss$2$1 = {};
  var LazyResult$2$1 = class LazyResult {
    constructor(processor2, css, opts) {
      this.stringified = false;
      this.processed = false;
      let root2;
      if (typeof css === "object" && css !== null && (css.type === "root" || css.type === "document")) {
        root2 = cleanMarks$1(css);
      } else if (css instanceof LazyResult || css instanceof Result$2$1) {
        root2 = cleanMarks$1(css.root);
        if (css.map) {
          if (typeof opts.map === "undefined") opts.map = {};
          if (!opts.map.inline) opts.map.inline = false;
          opts.map.prev = css.map;
        }
      } else {
        let parser2 = parse$2$1;
        if (opts.syntax) parser2 = opts.syntax.parse;
        if (opts.parser) parser2 = opts.parser;
        if (parser2.parse) parser2 = parser2.parse;
        try {
          root2 = parser2(css, opts);
        } catch (error) {
          this.processed = true;
          this.error = error;
        }
        if (root2 && !root2[my$3]) {
          Container$1$1.rebuild(root2);
        }
      }
      this.result = new Result$2$1(processor2, root2, opts);
      this.helpers = { ...postcss$2$1, postcss: postcss$2$1, result: this.result };
      this.plugins = this.processor.plugins.map((plugin22) => {
        if (typeof plugin22 === "object" && plugin22.prepare) {
          return { ...plugin22, ...plugin22.prepare(this.result) };
        } else {
          return plugin22;
        }
      });
    }
    async() {
      if (this.error) return Promise.reject(this.error);
      if (this.processed) return Promise.resolve(this.result);
      if (!this.processing) {
        this.processing = this.runAsync();
      }
      return this.processing;
    }
    catch(onRejected) {
      return this.async().catch(onRejected);
    }
    finally(onFinally) {
      return this.async().then(onFinally, onFinally);
    }
    getAsyncError() {
      throw new Error("Use process(css).then(cb) to work with async plugins");
    }
    handleError(error, node2) {
      let plugin22 = this.result.lastPlugin;
      try {
        if (node2) node2.addToError(error);
        this.error = error;
        if (error.name === "CssSyntaxError" && !error.plugin) {
          error.plugin = plugin22.postcssPlugin;
          error.setMessage();
        } else if (plugin22.postcssVersion) {
          if (true) {
            let pluginName = plugin22.postcssPlugin;
            let pluginVer = plugin22.postcssVersion;
            let runtimeVer = this.result.processor.version;
            let a2 = pluginVer.split(".");
            let b = runtimeVer.split(".");
            if (a2[0] !== b[0] || parseInt(a2[1]) > parseInt(b[1])) {
              console.error(
                "Unknown error from PostCSS plugin. Your current PostCSS version is " + runtimeVer + ", but " + pluginName + " uses " + pluginVer + ". Perhaps this is the source of the error below."
              );
            }
          }
        }
      } catch (err) {
        if (console && console.error) console.error(err);
      }
      return error;
    }
    prepareVisitors() {
      this.listeners = {};
      let add = (plugin22, type, cb) => {
        if (!this.listeners[type]) this.listeners[type] = [];
        this.listeners[type].push([plugin22, cb]);
      };
      for (let plugin22 of this.plugins) {
        if (typeof plugin22 === "object") {
          for (let event in plugin22) {
            if (!PLUGIN_PROPS$1[event] && /^[A-Z]/.test(event)) {
              throw new Error(
                `Unknown event ${event} in ${plugin22.postcssPlugin}. Try to update PostCSS (${this.processor.version} now).`
              );
            }
            if (!NOT_VISITORS$1[event]) {
              if (typeof plugin22[event] === "object") {
                for (let filter in plugin22[event]) {
                  if (filter === "*") {
                    add(plugin22, event, plugin22[event][filter]);
                  } else {
                    add(
                      plugin22,
                      event + "-" + filter.toLowerCase(),
                      plugin22[event][filter]
                    );
                  }
                }
              } else if (typeof plugin22[event] === "function") {
                add(plugin22, event, plugin22[event]);
              }
            }
          }
        }
      }
      this.hasListener = Object.keys(this.listeners).length > 0;
    }
    async runAsync() {
      this.plugin = 0;
      for (let i2 = 0; i2 < this.plugins.length; i2++) {
        let plugin22 = this.plugins[i2];
        let promise = this.runOnRoot(plugin22);
        if (isPromise$1(promise)) {
          try {
            await promise;
          } catch (error) {
            throw this.handleError(error);
          }
        }
      }
      this.prepareVisitors();
      if (this.hasListener) {
        let root2 = this.result.root;
        while (!root2[isClean$3]) {
          root2[isClean$3] = true;
          let stack = [toStack$1(root2)];
          while (stack.length > 0) {
            let promise = this.visitTick(stack);
            if (isPromise$1(promise)) {
              try {
                await promise;
              } catch (e2) {
                let node2 = stack[stack.length - 1].node;
                throw this.handleError(e2, node2);
              }
            }
          }
        }
        if (this.listeners.OnceExit) {
          for (let [plugin22, visitor] of this.listeners.OnceExit) {
            this.result.lastPlugin = plugin22;
            try {
              if (root2.type === "document") {
                let roots = root2.nodes.map(
                  (subRoot) => visitor(subRoot, this.helpers)
                );
                await Promise.all(roots);
              } else {
                await visitor(root2, this.helpers);
              }
            } catch (e2) {
              throw this.handleError(e2);
            }
          }
        }
      }
      this.processed = true;
      return this.stringify();
    }
    runOnRoot(plugin22) {
      this.result.lastPlugin = plugin22;
      try {
        if (typeof plugin22 === "object" && plugin22.Once) {
          if (this.result.root.type === "document") {
            let roots = this.result.root.nodes.map(
              (root2) => plugin22.Once(root2, this.helpers)
            );
            if (isPromise$1(roots[0])) {
              return Promise.all(roots);
            }
            return roots;
          }
          return plugin22.Once(this.result.root, this.helpers);
        } else if (typeof plugin22 === "function") {
          return plugin22(this.result.root, this.result);
        }
      } catch (error) {
        throw this.handleError(error);
      }
    }
    stringify() {
      if (this.error) throw this.error;
      if (this.stringified) return this.result;
      this.stringified = true;
      this.sync();
      let opts = this.result.opts;
      let str = stringify$2$1;
      if (opts.syntax) str = opts.syntax.stringify;
      if (opts.stringifier) str = opts.stringifier;
      if (str.stringify) str = str.stringify;
      let map = new MapGenerator$1$1(str, this.result.root, this.result.opts);
      let data = map.generate();
      this.result.css = data[0];
      this.result.map = data[1];
      return this.result;
    }
    sync() {
      if (this.error) throw this.error;
      if (this.processed) return this.result;
      this.processed = true;
      if (this.processing) {
        throw this.getAsyncError();
      }
      for (let plugin22 of this.plugins) {
        let promise = this.runOnRoot(plugin22);
        if (isPromise$1(promise)) {
          throw this.getAsyncError();
        }
      }
      this.prepareVisitors();
      if (this.hasListener) {
        let root2 = this.result.root;
        while (!root2[isClean$3]) {
          root2[isClean$3] = true;
          this.walkSync(root2);
        }
        if (this.listeners.OnceExit) {
          if (root2.type === "document") {
            for (let subRoot of root2.nodes) {
              this.visitSync(this.listeners.OnceExit, subRoot);
            }
          } else {
            this.visitSync(this.listeners.OnceExit, root2);
          }
        }
      }
      return this.result;
    }
    then(onFulfilled, onRejected) {
      if (true) {
        if (!("from" in this.opts)) {
          warnOnce$1$1(
            "Without `from` option PostCSS could generate wrong source map and will not find Browserslist config. Set it to CSS file path or to `undefined` to prevent this warning."
          );
        }
      }
      return this.async().then(onFulfilled, onRejected);
    }
    toString() {
      return this.css;
    }
    visitSync(visitors, node2) {
      for (let [plugin22, visitor] of visitors) {
        this.result.lastPlugin = plugin22;
        let promise;
        try {
          promise = visitor(node2, this.helpers);
        } catch (e2) {
          throw this.handleError(e2, node2.proxyOf);
        }
        if (node2.type !== "root" && node2.type !== "document" && !node2.parent) {
          return true;
        }
        if (isPromise$1(promise)) {
          throw this.getAsyncError();
        }
      }
    }
    visitTick(stack) {
      let visit2 = stack[stack.length - 1];
      let { node: node2, visitors } = visit2;
      if (node2.type !== "root" && node2.type !== "document" && !node2.parent) {
        stack.pop();
        return;
      }
      if (visitors.length > 0 && visit2.visitorIndex < visitors.length) {
        let [plugin22, visitor] = visitors[visit2.visitorIndex];
        visit2.visitorIndex += 1;
        if (visit2.visitorIndex === visitors.length) {
          visit2.visitors = [];
          visit2.visitorIndex = 0;
        }
        this.result.lastPlugin = plugin22;
        try {
          return visitor(node2.toProxy(), this.helpers);
        } catch (e2) {
          throw this.handleError(e2, node2);
        }
      }
      if (visit2.iterator !== 0) {
        let iterator = visit2.iterator;
        let child;
        while (child = node2.nodes[node2.indexes[iterator]]) {
          node2.indexes[iterator] += 1;
          if (!child[isClean$3]) {
            child[isClean$3] = true;
            stack.push(toStack$1(child));
            return;
          }
        }
        visit2.iterator = 0;
        delete node2.indexes[iterator];
      }
      let events = visit2.events;
      while (visit2.eventIndex < events.length) {
        let event = events[visit2.eventIndex];
        visit2.eventIndex += 1;
        if (event === CHILDREN$1) {
          if (node2.nodes && node2.nodes.length) {
            node2[isClean$3] = true;
            visit2.iterator = node2.getIterator();
          }
          return;
        } else if (this.listeners[event]) {
          visit2.visitors = this.listeners[event];
          return;
        }
      }
      stack.pop();
    }
    walkSync(node2) {
      node2[isClean$3] = true;
      let events = getEvents$1(node2);
      for (let event of events) {
        if (event === CHILDREN$1) {
          if (node2.nodes) {
            node2.each((child) => {
              if (!child[isClean$3]) this.walkSync(child);
            });
          }
        } else {
          let visitors = this.listeners[event];
          if (visitors) {
            if (this.visitSync(visitors, node2.toProxy())) return;
          }
        }
      }
    }
    warnings() {
      return this.sync().warnings();
    }
    get content() {
      return this.stringify().content;
    }
    get css() {
      return this.stringify().css;
    }
    get map() {
      return this.stringify().map;
    }
    get messages() {
      return this.sync().messages;
    }
    get opts() {
      return this.result.opts;
    }
    get processor() {
      return this.result.processor;
    }
    get root() {
      return this.sync().root;
    }
    get [Symbol.toStringTag]() {
      return "LazyResult";
    }
  };
  LazyResult$2$1.registerPostcss = (dependant) => {
    postcss$2$1 = dependant;
  };
  var lazyResult$1 = LazyResult$2$1;
  LazyResult$2$1.default = LazyResult$2$1;
  Root$3$1.registerLazyResult(LazyResult$2$1);
  Document$2$1.registerLazyResult(LazyResult$2$1);
  var MapGenerator2$1 = mapGenerator$1;
  var stringify$1$1 = stringify_1$1;
  var warnOnce2$1 = warnOnce$2$1;
  var parse$1$1 = parse_1$1;
  var Result$1$1 = result$1;
  var NoWorkResult$1$1 = class NoWorkResult {
    constructor(processor2, css, opts) {
      css = css.toString();
      this.stringified = false;
      this._processor = processor2;
      this._css = css;
      this._opts = opts;
      this._map = void 0;
      let root2;
      let str = stringify$1$1;
      this.result = new Result$1$1(this._processor, root2, this._opts);
      this.result.css = css;
      let self = this;
      Object.defineProperty(this.result, "root", {
        get() {
          return self.root;
        }
      });
      let map = new MapGenerator2$1(str, root2, this._opts, css);
      if (map.isMap()) {
        let [generatedCSS, generatedMap] = map.generate();
        if (generatedCSS) {
          this.result.css = generatedCSS;
        }
        if (generatedMap) {
          this.result.map = generatedMap;
        }
      } else {
        map.clearAnnotation();
        this.result.css = map.css;
      }
    }
    async() {
      if (this.error) return Promise.reject(this.error);
      return Promise.resolve(this.result);
    }
    catch(onRejected) {
      return this.async().catch(onRejected);
    }
    finally(onFinally) {
      return this.async().then(onFinally, onFinally);
    }
    sync() {
      if (this.error) throw this.error;
      return this.result;
    }
    then(onFulfilled, onRejected) {
      if (true) {
        if (!("from" in this._opts)) {
          warnOnce2$1(
            "Without `from` option PostCSS could generate wrong source map and will not find Browserslist config. Set it to CSS file path or to `undefined` to prevent this warning."
          );
        }
      }
      return this.async().then(onFulfilled, onRejected);
    }
    toString() {
      return this._css;
    }
    warnings() {
      return [];
    }
    get content() {
      return this.result.css;
    }
    get css() {
      return this.result.css;
    }
    get map() {
      return this.result.map;
    }
    get messages() {
      return [];
    }
    get opts() {
      return this.result.opts;
    }
    get processor() {
      return this.result.processor;
    }
    get root() {
      if (this._root) {
        return this._root;
      }
      let root2;
      let parser2 = parse$1$1;
      try {
        root2 = parser2(this._css, this._opts);
      } catch (error) {
        this.error = error;
      }
      if (this.error) {
        throw this.error;
      } else {
        this._root = root2;
        return root2;
      }
    }
    get [Symbol.toStringTag]() {
      return "NoWorkResult";
    }
  };
  var noWorkResult$1 = NoWorkResult$1$1;
  NoWorkResult$1$1.default = NoWorkResult$1$1;
  var NoWorkResult2$1 = noWorkResult$1;
  var LazyResult$1$1 = lazyResult$1;
  var Document$1$1 = document$1$1;
  var Root$2$1 = root$1;
  var Processor$1$1 = class Processor {
    constructor(plugins = []) {
      this.version = "8.4.38";
      this.plugins = this.normalize(plugins);
    }
    normalize(plugins) {
      let normalized = [];
      for (let i2 of plugins) {
        if (i2.postcss === true) {
          i2 = i2();
        } else if (i2.postcss) {
          i2 = i2.postcss;
        }
        if (typeof i2 === "object" && Array.isArray(i2.plugins)) {
          normalized = normalized.concat(i2.plugins);
        } else if (typeof i2 === "object" && i2.postcssPlugin) {
          normalized.push(i2);
        } else if (typeof i2 === "function") {
          normalized.push(i2);
        } else if (typeof i2 === "object" && (i2.parse || i2.stringify)) {
          if (true) {
            throw new Error(
              "PostCSS syntaxes cannot be used as plugins. Instead, please use one of the syntax/parser/stringifier options as outlined in your PostCSS runner documentation."
            );
          }
        } else {
          throw new Error(i2 + " is not a PostCSS plugin");
        }
      }
      return normalized;
    }
    process(css, opts = {}) {
      if (!this.plugins.length && !opts.parser && !opts.stringifier && !opts.syntax) {
        return new NoWorkResult2$1(this, css, opts);
      } else {
        return new LazyResult$1$1(this, css, opts);
      }
    }
    use(plugin22) {
      this.plugins = this.plugins.concat(this.normalize([plugin22]));
      return this;
    }
  };
  var processor$1 = Processor$1$1;
  Processor$1$1.default = Processor$1$1;
  Root$2$1.registerProcessor(Processor$1$1);
  Document$1$1.registerProcessor(Processor$1$1);
  var Declaration$1$1 = declaration$1;
  var PreviousMap2$1 = previousMap$1;
  var Comment$1$1 = comment$1;
  var AtRule$1$1 = atRule$1;
  var Input$1$1 = input$1;
  var Root$1$1 = root$1;
  var Rule$1$1 = rule$1;
  function fromJSON$1$1(json, inputs) {
    if (Array.isArray(json)) return json.map((n2) => fromJSON$1$1(n2));
    let { inputs: ownInputs, ...defaults } = json;
    if (ownInputs) {
      inputs = [];
      for (let input2 of ownInputs) {
        let inputHydrated = { ...input2, __proto__: Input$1$1.prototype };
        if (inputHydrated.map) {
          inputHydrated.map = {
            ...inputHydrated.map,
            __proto__: PreviousMap2$1.prototype
          };
        }
        inputs.push(inputHydrated);
      }
    }
    if (defaults.nodes) {
      defaults.nodes = json.nodes.map((n2) => fromJSON$1$1(n2, inputs));
    }
    if (defaults.source) {
      let { inputId, ...source } = defaults.source;
      defaults.source = source;
      if (inputId != null) {
        defaults.source.input = inputs[inputId];
      }
    }
    if (defaults.type === "root") {
      return new Root$1$1(defaults);
    } else if (defaults.type === "decl") {
      return new Declaration$1$1(defaults);
    } else if (defaults.type === "rule") {
      return new Rule$1$1(defaults);
    } else if (defaults.type === "comment") {
      return new Comment$1$1(defaults);
    } else if (defaults.type === "atrule") {
      return new AtRule$1$1(defaults);
    } else {
      throw new Error("Unknown node type: " + json.type);
    }
  }
  var fromJSON_1$1 = fromJSON$1$1;
  fromJSON$1$1.default = fromJSON$1$1;
  var CssSyntaxError2$1 = cssSyntaxError$1;
  var Declaration2$1 = declaration$1;
  var LazyResult2$1 = lazyResult$1;
  var Container2$1 = container$1;
  var Processor2$1 = processor$1;
  var stringify$5 = stringify_1$1;
  var fromJSON$2 = fromJSON_1$1;
  var Document22 = document$1$1;
  var Warning2$1 = warning$1;
  var Comment2$1 = comment$1;
  var AtRule2$1 = atRule$1;
  var Result2$1 = result$1;
  var Input2$1 = input$1;
  var parse$5 = parse_1$1;
  var list$3 = list_1$1;
  var Rule2$1 = rule$1;
  var Root2$1 = root$1;
  var Node2$1 = node$1;
  function postcss$3(...plugins) {
    if (plugins.length === 1 && Array.isArray(plugins[0])) {
      plugins = plugins[0];
    }
    return new Processor2$1(plugins);
  }
  postcss$3.plugin = function plugin(name, initializer) {
    let warningPrinted = false;
    function creator(...args) {
      if (console && console.warn && !warningPrinted) {
        warningPrinted = true;
        console.warn(
          name + ": postcss.plugin was deprecated. Migration guide:\nhttps://evilmartians.com/chronicles/postcss-8-plugin-migration"
        );
        if (process.env.LANG && process.env.LANG.startsWith("cn")) {
          console.warn(
            name + ": \u91CC\u9762 postcss.plugin \u88AB\u5F03\u7528. \u8FC1\u79FB\u6307\u5357:\nhttps://www.w3ctech.com/topic/2226"
          );
        }
      }
      let transformer = initializer(...args);
      transformer.postcssPlugin = name;
      transformer.postcssVersion = new Processor2$1().version;
      return transformer;
    }
    let cache;
    Object.defineProperty(creator, "postcss", {
      get() {
        if (!cache) cache = creator();
        return cache;
      }
    });
    creator.process = function(css, processOpts, pluginOpts) {
      return postcss$3([creator(pluginOpts)]).process(css, processOpts);
    };
    return creator;
  };
  postcss$3.stringify = stringify$5;
  postcss$3.parse = parse$5;
  postcss$3.fromJSON = fromJSON$2;
  postcss$3.list = list$3;
  postcss$3.comment = (defaults) => new Comment2$1(defaults);
  postcss$3.atRule = (defaults) => new AtRule2$1(defaults);
  postcss$3.decl = (defaults) => new Declaration2$1(defaults);
  postcss$3.rule = (defaults) => new Rule2$1(defaults);
  postcss$3.root = (defaults) => new Root2$1(defaults);
  postcss$3.document = (defaults) => new Document22(defaults);
  postcss$3.CssSyntaxError = CssSyntaxError2$1;
  postcss$3.Declaration = Declaration2$1;
  postcss$3.Container = Container2$1;
  postcss$3.Processor = Processor2$1;
  postcss$3.Document = Document22;
  postcss$3.Comment = Comment2$1;
  postcss$3.Warning = Warning2$1;
  postcss$3.AtRule = AtRule2$1;
  postcss$3.Result = Result2$1;
  postcss$3.Input = Input2$1;
  postcss$3.Rule = Rule2$1;
  postcss$3.Root = Root2$1;
  postcss$3.Node = Node2$1;
  LazyResult2$1.registerPostcss(postcss$3);
  var postcss_1$1 = postcss$3;
  postcss$3.default = postcss$3;
  var postcss$1$1 = /* @__PURE__ */ getDefaultExportFromCjs$1(postcss_1$1);
  postcss$1$1.stringify;
  postcss$1$1.fromJSON;
  postcss$1$1.plugin;
  postcss$1$1.parse;
  postcss$1$1.list;
  postcss$1$1.document;
  postcss$1$1.comment;
  postcss$1$1.atRule;
  postcss$1$1.rule;
  postcss$1$1.decl;
  postcss$1$1.root;
  postcss$1$1.CssSyntaxError;
  postcss$1$1.Declaration;
  postcss$1$1.Container;
  postcss$1$1.Processor;
  postcss$1$1.Document;
  postcss$1$1.Comment;
  postcss$1$1.Warning;
  postcss$1$1.AtRule;
  postcss$1$1.Result;
  postcss$1$1.Input;
  postcss$1$1.Rule;
  postcss$1$1.Root;
  postcss$1$1.Node;
  var __defProp2 = Object.defineProperty;
  var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
  var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
  function getDefaultExportFromCjs(x2) {
    return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
  }
  function getAugmentedNamespace(n2) {
    if (n2.__esModule) return n2;
    var f2 = n2.default;
    if (typeof f2 == "function") {
      var a2 = function a22() {
        if (this instanceof a22) {
          return Reflect.construct(f2, arguments, this.constructor);
        }
        return f2.apply(this, arguments);
      };
      a2.prototype = f2.prototype;
    } else a2 = {};
    Object.defineProperty(a2, "__esModule", { value: true });
    Object.keys(n2).forEach(function(k) {
      var d = Object.getOwnPropertyDescriptor(n2, k);
      Object.defineProperty(a2, k, d.get ? d : {
        enumerable: true,
        get: function() {
          return n2[k];
        }
      });
    });
    return a2;
  }
  var picocolors_browser = { exports: {} };
  var x = String;
  var create = function() {
    return { isColorSupported: false, reset: x, bold: x, dim: x, italic: x, underline: x, inverse: x, hidden: x, strikethrough: x, black: x, red: x, green: x, yellow: x, blue: x, magenta: x, cyan: x, white: x, gray: x, bgBlack: x, bgRed: x, bgGreen: x, bgYellow: x, bgBlue: x, bgMagenta: x, bgCyan: x, bgWhite: x };
  };
  picocolors_browser.exports = create();
  picocolors_browser.exports.createColors = create;
  var picocolors_browserExports = picocolors_browser.exports;
  var __viteBrowserExternal = {};
  var __viteBrowserExternal$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
    __proto__: null,
    default: __viteBrowserExternal
  }, Symbol.toStringTag, { value: "Module" }));
  var require$$2 = /* @__PURE__ */ getAugmentedNamespace(__viteBrowserExternal$1);
  var pico = picocolors_browserExports;
  var terminalHighlight$1 = require$$2;
  var CssSyntaxError$3 = class CssSyntaxError2 extends Error {
    constructor(message, line, column, source, file, plugin22) {
      super(message);
      this.name = "CssSyntaxError";
      this.reason = message;
      if (file) {
        this.file = file;
      }
      if (source) {
        this.source = source;
      }
      if (plugin22) {
        this.plugin = plugin22;
      }
      if (typeof line !== "undefined" && typeof column !== "undefined") {
        if (typeof line === "number") {
          this.line = line;
          this.column = column;
        } else {
          this.line = line.line;
          this.column = line.column;
          this.endLine = column.line;
          this.endColumn = column.column;
        }
      }
      this.setMessage();
      if (Error.captureStackTrace) {
        Error.captureStackTrace(this, CssSyntaxError2);
      }
    }
    setMessage() {
      this.message = this.plugin ? this.plugin + ": " : "";
      this.message += this.file ? this.file : "<css input>";
      if (typeof this.line !== "undefined") {
        this.message += ":" + this.line + ":" + this.column;
      }
      this.message += ": " + this.reason;
    }
    showSourceCode(color) {
      if (!this.source) return "";
      let css = this.source;
      if (color == null) color = pico.isColorSupported;
      if (terminalHighlight$1) {
        if (color) css = terminalHighlight$1(css);
      }
      let lines = css.split(/\r?\n/);
      let start = Math.max(this.line - 3, 0);
      let end = Math.min(this.line + 2, lines.length);
      let maxWidth = String(end).length;
      let mark, aside;
      if (color) {
        let { bold, gray, red } = pico.createColors(true);
        mark = (text) => bold(red(text));
        aside = (text) => gray(text);
      } else {
        mark = aside = (str) => str;
      }
      return lines.slice(start, end).map((line, index2) => {
        let number = start + 1 + index2;
        let gutter = " " + (" " + number).slice(-maxWidth) + " | ";
        if (number === this.line) {
          let spacing = aside(gutter.replace(/\d/g, " ")) + line.slice(0, this.column - 1).replace(/[^\t]/g, " ");
          return mark(">") + aside(gutter) + line + "\n " + spacing + mark("^");
        }
        return " " + aside(gutter) + line;
      }).join("\n");
    }
    toString() {
      let code = this.showSourceCode();
      if (code) {
        code = "\n\n" + code + "\n";
      }
      return this.name + ": " + this.message + code;
    }
  };
  var cssSyntaxError = CssSyntaxError$3;
  CssSyntaxError$3.default = CssSyntaxError$3;
  var symbols = {};
  symbols.isClean = /* @__PURE__ */ Symbol("isClean");
  symbols.my = /* @__PURE__ */ Symbol("my");
  var DEFAULT_RAW = {
    after: "\n",
    beforeClose: "\n",
    beforeComment: "\n",
    beforeDecl: "\n",
    beforeOpen: " ",
    beforeRule: "\n",
    colon: ": ",
    commentLeft: " ",
    commentRight: " ",
    emptyBody: "",
    indent: "    ",
    semicolon: false
  };
  function capitalize(str) {
    return str[0].toUpperCase() + str.slice(1);
  }
  var Stringifier$2 = class Stringifier2 {
    constructor(builder) {
      this.builder = builder;
    }
    atrule(node2, semicolon) {
      let name = "@" + node2.name;
      let params = node2.params ? this.rawValue(node2, "params") : "";
      if (typeof node2.raws.afterName !== "undefined") {
        name += node2.raws.afterName;
      } else if (params) {
        name += " ";
      }
      if (node2.nodes) {
        this.block(node2, name + params);
      } else {
        let end = (node2.raws.between || "") + (semicolon ? ";" : "");
        this.builder(name + params + end, node2);
      }
    }
    beforeAfter(node2, detect) {
      let value;
      if (node2.type === "decl") {
        value = this.raw(node2, null, "beforeDecl");
      } else if (node2.type === "comment") {
        value = this.raw(node2, null, "beforeComment");
      } else if (detect === "before") {
        value = this.raw(node2, null, "beforeRule");
      } else {
        value = this.raw(node2, null, "beforeClose");
      }
      let buf = node2.parent;
      let depth = 0;
      while (buf && buf.type !== "root") {
        depth += 1;
        buf = buf.parent;
      }
      if (value.includes("\n")) {
        let indent = this.raw(node2, null, "indent");
        if (indent.length) {
          for (let step = 0; step < depth; step++) value += indent;
        }
      }
      return value;
    }
    block(node2, start) {
      let between = this.raw(node2, "between", "beforeOpen");
      this.builder(start + between + "{", node2, "start");
      let after;
      if (node2.nodes && node2.nodes.length) {
        this.body(node2);
        after = this.raw(node2, "after");
      } else {
        after = this.raw(node2, "after", "emptyBody");
      }
      if (after) this.builder(after);
      this.builder("}", node2, "end");
    }
    body(node2) {
      let last = node2.nodes.length - 1;
      while (last > 0) {
        if (node2.nodes[last].type !== "comment") break;
        last -= 1;
      }
      let semicolon = this.raw(node2, "semicolon");
      for (let i2 = 0; i2 < node2.nodes.length; i2++) {
        let child = node2.nodes[i2];
        let before = this.raw(child, "before");
        if (before) this.builder(before);
        this.stringify(child, last !== i2 || semicolon);
      }
    }
    comment(node2) {
      let left = this.raw(node2, "left", "commentLeft");
      let right = this.raw(node2, "right", "commentRight");
      this.builder("/*" + left + node2.text + right + "*/", node2);
    }
    decl(node2, semicolon) {
      let between = this.raw(node2, "between", "colon");
      let string = node2.prop + between + this.rawValue(node2, "value");
      if (node2.important) {
        string += node2.raws.important || " !important";
      }
      if (semicolon) string += ";";
      this.builder(string, node2);
    }
    document(node2) {
      this.body(node2);
    }
    raw(node2, own, detect) {
      let value;
      if (!detect) detect = own;
      if (own) {
        value = node2.raws[own];
        if (typeof value !== "undefined") return value;
      }
      let parent = node2.parent;
      if (detect === "before") {
        if (!parent || parent.type === "root" && parent.first === node2) {
          return "";
        }
        if (parent && parent.type === "document") {
          return "";
        }
      }
      if (!parent) return DEFAULT_RAW[detect];
      let root2 = node2.root();
      if (!root2.rawCache) root2.rawCache = {};
      if (typeof root2.rawCache[detect] !== "undefined") {
        return root2.rawCache[detect];
      }
      if (detect === "before" || detect === "after") {
        return this.beforeAfter(node2, detect);
      } else {
        let method = "raw" + capitalize(detect);
        if (this[method]) {
          value = this[method](root2, node2);
        } else {
          root2.walk((i2) => {
            value = i2.raws[own];
            if (typeof value !== "undefined") return false;
          });
        }
      }
      if (typeof value === "undefined") value = DEFAULT_RAW[detect];
      root2.rawCache[detect] = value;
      return value;
    }
    rawBeforeClose(root2) {
      let value;
      root2.walk((i2) => {
        if (i2.nodes && i2.nodes.length > 0) {
          if (typeof i2.raws.after !== "undefined") {
            value = i2.raws.after;
            if (value.includes("\n")) {
              value = value.replace(/[^\n]+$/, "");
            }
            return false;
          }
        }
      });
      if (value) value = value.replace(/\S/g, "");
      return value;
    }
    rawBeforeComment(root2, node2) {
      let value;
      root2.walkComments((i2) => {
        if (typeof i2.raws.before !== "undefined") {
          value = i2.raws.before;
          if (value.includes("\n")) {
            value = value.replace(/[^\n]+$/, "");
          }
          return false;
        }
      });
      if (typeof value === "undefined") {
        value = this.raw(node2, null, "beforeDecl");
      } else if (value) {
        value = value.replace(/\S/g, "");
      }
      return value;
    }
    rawBeforeDecl(root2, node2) {
      let value;
      root2.walkDecls((i2) => {
        if (typeof i2.raws.before !== "undefined") {
          value = i2.raws.before;
          if (value.includes("\n")) {
            value = value.replace(/[^\n]+$/, "");
          }
          return false;
        }
      });
      if (typeof value === "undefined") {
        value = this.raw(node2, null, "beforeRule");
      } else if (value) {
        value = value.replace(/\S/g, "");
      }
      return value;
    }
    rawBeforeOpen(root2) {
      let value;
      root2.walk((i2) => {
        if (i2.type !== "decl") {
          value = i2.raws.between;
          if (typeof value !== "undefined") return false;
        }
      });
      return value;
    }
    rawBeforeRule(root2) {
      let value;
      root2.walk((i2) => {
        if (i2.nodes && (i2.parent !== root2 || root2.first !== i2)) {
          if (typeof i2.raws.before !== "undefined") {
            value = i2.raws.before;
            if (value.includes("\n")) {
              value = value.replace(/[^\n]+$/, "");
            }
            return false;
          }
        }
      });
      if (value) value = value.replace(/\S/g, "");
      return value;
    }
    rawColon(root2) {
      let value;
      root2.walkDecls((i2) => {
        if (typeof i2.raws.between !== "undefined") {
          value = i2.raws.between.replace(/[^\s:]/g, "");
          return false;
        }
      });
      return value;
    }
    rawEmptyBody(root2) {
      let value;
      root2.walk((i2) => {
        if (i2.nodes && i2.nodes.length === 0) {
          value = i2.raws.after;
          if (typeof value !== "undefined") return false;
        }
      });
      return value;
    }
    rawIndent(root2) {
      if (root2.raws.indent) return root2.raws.indent;
      let value;
      root2.walk((i2) => {
        let p = i2.parent;
        if (p && p !== root2 && p.parent && p.parent === root2) {
          if (typeof i2.raws.before !== "undefined") {
            let parts = i2.raws.before.split("\n");
            value = parts[parts.length - 1];
            value = value.replace(/\S/g, "");
            return false;
          }
        }
      });
      return value;
    }
    rawSemicolon(root2) {
      let value;
      root2.walk((i2) => {
        if (i2.nodes && i2.nodes.length && i2.last.type === "decl") {
          value = i2.raws.semicolon;
          if (typeof value !== "undefined") return false;
        }
      });
      return value;
    }
    rawValue(node2, prop) {
      let value = node2[prop];
      let raw = node2.raws[prop];
      if (raw && raw.value === value) {
        return raw.raw;
      }
      return value;
    }
    root(node2) {
      this.body(node2);
      if (node2.raws.after) this.builder(node2.raws.after);
    }
    rule(node2) {
      this.block(node2, this.rawValue(node2, "selector"));
      if (node2.raws.ownSemicolon) {
        this.builder(node2.raws.ownSemicolon, node2, "end");
      }
    }
    stringify(node2, semicolon) {
      if (!this[node2.type]) {
        throw new Error(
          "Unknown AST node type " + node2.type + ". Maybe you need to change PostCSS stringifier."
        );
      }
      this[node2.type](node2, semicolon);
    }
  };
  var stringifier = Stringifier$2;
  Stringifier$2.default = Stringifier$2;
  var Stringifier$1 = stringifier;
  function stringify$4(node2, builder) {
    let str = new Stringifier$1(builder);
    str.stringify(node2);
  }
  var stringify_1 = stringify$4;
  stringify$4.default = stringify$4;
  var { isClean: isClean$2, my: my$2 } = symbols;
  var CssSyntaxError$2 = cssSyntaxError;
  var Stringifier22 = stringifier;
  var stringify$3 = stringify_1;
  function cloneNode(obj, parent) {
    let cloned = new obj.constructor();
    for (let i2 in obj) {
      if (!Object.prototype.hasOwnProperty.call(obj, i2)) {
        continue;
      }
      if (i2 === "proxyCache") continue;
      let value = obj[i2];
      let type = typeof value;
      if (i2 === "parent" && type === "object") {
        if (parent) cloned[i2] = parent;
      } else if (i2 === "source") {
        cloned[i2] = value;
      } else if (Array.isArray(value)) {
        cloned[i2] = value.map((j) => cloneNode(j, cloned));
      } else {
        if (type === "object" && value !== null) value = cloneNode(value);
        cloned[i2] = value;
      }
    }
    return cloned;
  }
  var Node$4 = class Node3 {
    constructor(defaults = {}) {
      this.raws = {};
      this[isClean$2] = false;
      this[my$2] = true;
      for (let name in defaults) {
        if (name === "nodes") {
          this.nodes = [];
          for (let node2 of defaults[name]) {
            if (typeof node2.clone === "function") {
              this.append(node2.clone());
            } else {
              this.append(node2);
            }
          }
        } else {
          this[name] = defaults[name];
        }
      }
    }
    addToError(error) {
      error.postcssNode = this;
      if (error.stack && this.source && /\n\s{4}at /.test(error.stack)) {
        let s2 = this.source;
        error.stack = error.stack.replace(
          /\n\s{4}at /,
          `$&${s2.input.from}:${s2.start.line}:${s2.start.column}$&`
        );
      }
      return error;
    }
    after(add) {
      this.parent.insertAfter(this, add);
      return this;
    }
    assign(overrides = {}) {
      for (let name in overrides) {
        this[name] = overrides[name];
      }
      return this;
    }
    before(add) {
      this.parent.insertBefore(this, add);
      return this;
    }
    cleanRaws(keepBetween) {
      delete this.raws.before;
      delete this.raws.after;
      if (!keepBetween) delete this.raws.between;
    }
    clone(overrides = {}) {
      let cloned = cloneNode(this);
      for (let name in overrides) {
        cloned[name] = overrides[name];
      }
      return cloned;
    }
    cloneAfter(overrides = {}) {
      let cloned = this.clone(overrides);
      this.parent.insertAfter(this, cloned);
      return cloned;
    }
    cloneBefore(overrides = {}) {
      let cloned = this.clone(overrides);
      this.parent.insertBefore(this, cloned);
      return cloned;
    }
    error(message, opts = {}) {
      if (this.source) {
        let { end, start } = this.rangeBy(opts);
        return this.source.input.error(
          message,
          { column: start.column, line: start.line },
          { column: end.column, line: end.line },
          opts
        );
      }
      return new CssSyntaxError$2(message);
    }
    getProxyProcessor() {
      return {
        get(node2, prop) {
          if (prop === "proxyOf") {
            return node2;
          } else if (prop === "root") {
            return () => node2.root().toProxy();
          } else {
            return node2[prop];
          }
        },
        set(node2, prop, value) {
          if (node2[prop] === value) return true;
          node2[prop] = value;
          if (prop === "prop" || prop === "value" || prop === "name" || prop === "params" || prop === "important" || /* c8 ignore next */
          prop === "text") {
            node2.markDirty();
          }
          return true;
        }
      };
    }
    markDirty() {
      if (this[isClean$2]) {
        this[isClean$2] = false;
        let next = this;
        while (next = next.parent) {
          next[isClean$2] = false;
        }
      }
    }
    next() {
      if (!this.parent) return void 0;
      let index2 = this.parent.index(this);
      return this.parent.nodes[index2 + 1];
    }
    positionBy(opts, stringRepresentation) {
      let pos = this.source.start;
      if (opts.index) {
        pos = this.positionInside(opts.index, stringRepresentation);
      } else if (opts.word) {
        stringRepresentation = this.toString();
        let index2 = stringRepresentation.indexOf(opts.word);
        if (index2 !== -1) pos = this.positionInside(index2, stringRepresentation);
      }
      return pos;
    }
    positionInside(index2, stringRepresentation) {
      let string = stringRepresentation || this.toString();
      let column = this.source.start.column;
      let line = this.source.start.line;
      for (let i2 = 0; i2 < index2; i2++) {
        if (string[i2] === "\n") {
          column = 1;
          line += 1;
        } else {
          column += 1;
        }
      }
      return { column, line };
    }
    prev() {
      if (!this.parent) return void 0;
      let index2 = this.parent.index(this);
      return this.parent.nodes[index2 - 1];
    }
    rangeBy(opts) {
      let start = {
        column: this.source.start.column,
        line: this.source.start.line
      };
      let end = this.source.end ? {
        column: this.source.end.column + 1,
        line: this.source.end.line
      } : {
        column: start.column + 1,
        line: start.line
      };
      if (opts.word) {
        let stringRepresentation = this.toString();
        let index2 = stringRepresentation.indexOf(opts.word);
        if (index2 !== -1) {
          start = this.positionInside(index2, stringRepresentation);
          end = this.positionInside(index2 + opts.word.length, stringRepresentation);
        }
      } else {
        if (opts.start) {
          start = {
            column: opts.start.column,
            line: opts.start.line
          };
        } else if (opts.index) {
          start = this.positionInside(opts.index);
        }
        if (opts.end) {
          end = {
            column: opts.end.column,
            line: opts.end.line
          };
        } else if (typeof opts.endIndex === "number") {
          end = this.positionInside(opts.endIndex);
        } else if (opts.index) {
          end = this.positionInside(opts.index + 1);
        }
      }
      if (end.line < start.line || end.line === start.line && end.column <= start.column) {
        end = { column: start.column + 1, line: start.line };
      }
      return { end, start };
    }
    raw(prop, defaultType) {
      let str = new Stringifier22();
      return str.raw(this, prop, defaultType);
    }
    remove() {
      if (this.parent) {
        this.parent.removeChild(this);
      }
      this.parent = void 0;
      return this;
    }
    replaceWith(...nodes) {
      if (this.parent) {
        let bookmark = this;
        let foundSelf = false;
        for (let node2 of nodes) {
          if (node2 === this) {
            foundSelf = true;
          } else if (foundSelf) {
            this.parent.insertAfter(bookmark, node2);
            bookmark = node2;
          } else {
            this.parent.insertBefore(bookmark, node2);
          }
        }
        if (!foundSelf) {
          this.remove();
        }
      }
      return this;
    }
    root() {
      let result2 = this;
      while (result2.parent && result2.parent.type !== "document") {
        result2 = result2.parent;
      }
      return result2;
    }
    toJSON(_, inputs) {
      let fixed = {};
      let emitInputs = inputs == null;
      inputs = inputs || /* @__PURE__ */ new Map();
      let inputsNextIndex = 0;
      for (let name in this) {
        if (!Object.prototype.hasOwnProperty.call(this, name)) {
          continue;
        }
        if (name === "parent" || name === "proxyCache") continue;
        let value = this[name];
        if (Array.isArray(value)) {
          fixed[name] = value.map((i2) => {
            if (typeof i2 === "object" && i2.toJSON) {
              return i2.toJSON(null, inputs);
            } else {
              return i2;
            }
          });
        } else if (typeof value === "object" && value.toJSON) {
          fixed[name] = value.toJSON(null, inputs);
        } else if (name === "source") {
          let inputId = inputs.get(value.input);
          if (inputId == null) {
            inputId = inputsNextIndex;
            inputs.set(value.input, inputsNextIndex);
            inputsNextIndex++;
          }
          fixed[name] = {
            end: value.end,
            inputId,
            start: value.start
          };
        } else {
          fixed[name] = value;
        }
      }
      if (emitInputs) {
        fixed.inputs = [...inputs.keys()].map((input2) => input2.toJSON());
      }
      return fixed;
    }
    toProxy() {
      if (!this.proxyCache) {
        this.proxyCache = new Proxy(this, this.getProxyProcessor());
      }
      return this.proxyCache;
    }
    toString(stringifier2 = stringify$3) {
      if (stringifier2.stringify) stringifier2 = stringifier2.stringify;
      let result2 = "";
      stringifier2(this, (i2) => {
        result2 += i2;
      });
      return result2;
    }
    warn(result2, text, opts) {
      let data = { node: this };
      for (let i2 in opts) data[i2] = opts[i2];
      return result2.warn(text, data);
    }
    get proxyOf() {
      return this;
    }
  };
  var node = Node$4;
  Node$4.default = Node$4;
  var Node$3 = node;
  var Declaration$4 = class Declaration2 extends Node$3 {
    constructor(defaults) {
      if (defaults && typeof defaults.value !== "undefined" && typeof defaults.value !== "string") {
        defaults = { ...defaults, value: String(defaults.value) };
      }
      super(defaults);
      this.type = "decl";
    }
    get variable() {
      return this.prop.startsWith("--") || this.prop[0] === "$";
    }
  };
  var declaration = Declaration$4;
  Declaration$4.default = Declaration$4;
  var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
  var customAlphabet = (alphabet, defaultSize = 21) => {
    return (size = defaultSize) => {
      let id = "";
      let i2 = size;
      while (i2--) {
        id += alphabet[Math.random() * alphabet.length | 0];
      }
      return id;
    };
  };
  var nanoid$1 = (size = 21) => {
    let id = "";
    let i2 = size;
    while (i2--) {
      id += urlAlphabet[Math.random() * 64 | 0];
    }
    return id;
  };
  var nonSecure = { nanoid: nanoid$1, customAlphabet };
  var { SourceMapConsumer: SourceMapConsumer$2, SourceMapGenerator: SourceMapGenerator$2 } = require$$2;
  var { existsSync, readFileSync } = require$$2;
  var { dirname: dirname$1, join } = require$$2;
  function fromBase64(str) {
    if (Buffer) {
      return Buffer.from(str, "base64").toString();
    } else {
      return window.atob(str);
    }
  }
  var PreviousMap$2 = class PreviousMap2 {
    constructor(css, opts) {
      if (opts.map === false) return;
      this.loadAnnotation(css);
      this.inline = this.startWith(this.annotation, "data:");
      let prev = opts.map ? opts.map.prev : void 0;
      let text = this.loadMap(opts.from, prev);
      if (!this.mapFile && opts.from) {
        this.mapFile = opts.from;
      }
      if (this.mapFile) this.root = dirname$1(this.mapFile);
      if (text) this.text = text;
    }
    consumer() {
      if (!this.consumerCache) {
        this.consumerCache = new SourceMapConsumer$2(this.text);
      }
      return this.consumerCache;
    }
    decodeInline(text) {
      let baseCharsetUri = /^data:application\/json;charset=utf-?8;base64,/;
      let baseUri = /^data:application\/json;base64,/;
      let charsetUri = /^data:application\/json;charset=utf-?8,/;
      let uri = /^data:application\/json,/;
      if (charsetUri.test(text) || uri.test(text)) {
        return decodeURIComponent(text.substr(RegExp.lastMatch.length));
      }
      if (baseCharsetUri.test(text) || baseUri.test(text)) {
        return fromBase64(text.substr(RegExp.lastMatch.length));
      }
      let encoding = text.match(/data:application\/json;([^,]+),/)[1];
      throw new Error("Unsupported source map encoding " + encoding);
    }
    getAnnotationURL(sourceMapString) {
      return sourceMapString.replace(/^\/\*\s*# sourceMappingURL=/, "").trim();
    }
    isMap(map) {
      if (typeof map !== "object") return false;
      return typeof map.mappings === "string" || typeof map._mappings === "string" || Array.isArray(map.sections);
    }
    loadAnnotation(css) {
      let comments = css.match(/\/\*\s*# sourceMappingURL=/gm);
      if (!comments) return;
      let start = css.lastIndexOf(comments.pop());
      let end = css.indexOf("*/", start);
      if (start > -1 && end > -1) {
        this.annotation = this.getAnnotationURL(css.substring(start, end));
      }
    }
    loadFile(path) {
      this.root = dirname$1(path);
      if (existsSync(path)) {
        this.mapFile = path;
        return readFileSync(path, "utf-8").toString().trim();
      }
    }
    loadMap(file, prev) {
      if (prev === false) return false;
      if (prev) {
        if (typeof prev === "string") {
          return prev;
        } else if (typeof prev === "function") {
          let prevPath = prev(file);
          if (prevPath) {
            let map = this.loadFile(prevPath);
            if (!map) {
              throw new Error(
                "Unable to load previous source map: " + prevPath.toString()
              );
            }
            return map;
          }
        } else if (prev instanceof SourceMapConsumer$2) {
          return SourceMapGenerator$2.fromSourceMap(prev).toString();
        } else if (prev instanceof SourceMapGenerator$2) {
          return prev.toString();
        } else if (this.isMap(prev)) {
          return JSON.stringify(prev);
        } else {
          throw new Error(
            "Unsupported previous source map format: " + prev.toString()
          );
        }
      } else if (this.inline) {
        return this.decodeInline(this.annotation);
      } else if (this.annotation) {
        let map = this.annotation;
        if (file) map = join(dirname$1(file), map);
        return this.loadFile(map);
      }
    }
    startWith(string, start) {
      if (!string) return false;
      return string.substr(0, start.length) === start;
    }
    withContent() {
      return !!(this.consumer().sourcesContent && this.consumer().sourcesContent.length > 0);
    }
  };
  var previousMap = PreviousMap$2;
  PreviousMap$2.default = PreviousMap$2;
  var { SourceMapConsumer: SourceMapConsumer$1, SourceMapGenerator: SourceMapGenerator$1 } = require$$2;
  var { fileURLToPath, pathToFileURL: pathToFileURL$1 } = require$$2;
  var { isAbsolute, resolve: resolve$1 } = require$$2;
  var { nanoid } = nonSecure;
  var terminalHighlight = require$$2;
  var CssSyntaxError$1 = cssSyntaxError;
  var PreviousMap$1 = previousMap;
  var fromOffsetCache = /* @__PURE__ */ Symbol("fromOffsetCache");
  var sourceMapAvailable$1 = Boolean(SourceMapConsumer$1 && SourceMapGenerator$1);
  var pathAvailable$1 = Boolean(resolve$1 && isAbsolute);
  var Input$4 = class Input2 {
    constructor(css, opts = {}) {
      if (css === null || typeof css === "undefined" || typeof css === "object" && !css.toString) {
        throw new Error(`PostCSS received ${css} instead of CSS string`);
      }
      this.css = css.toString();
      if (this.css[0] === "\uFEFF" || this.css[0] === "\uFFFE") {
        this.hasBOM = true;
        this.css = this.css.slice(1);
      } else {
        this.hasBOM = false;
      }
      if (opts.from) {
        if (!pathAvailable$1 || /^\w+:\/\//.test(opts.from) || isAbsolute(opts.from)) {
          this.file = opts.from;
        } else {
          this.file = resolve$1(opts.from);
        }
      }
      if (pathAvailable$1 && sourceMapAvailable$1) {
        let map = new PreviousMap$1(this.css, opts);
        if (map.text) {
          this.map = map;
          let file = map.consumer().file;
          if (!this.file && file) this.file = this.mapResolve(file);
        }
      }
      if (!this.file) {
        this.id = "<input css " + nanoid(6) + ">";
      }
      if (this.map) this.map.file = this.from;
    }
    error(message, line, column, opts = {}) {
      let result2, endLine, endColumn;
      if (line && typeof line === "object") {
        let start = line;
        let end = column;
        if (typeof start.offset === "number") {
          let pos = this.fromOffset(start.offset);
          line = pos.line;
          column = pos.col;
        } else {
          line = start.line;
          column = start.column;
        }
        if (typeof end.offset === "number") {
          let pos = this.fromOffset(end.offset);
          endLine = pos.line;
          endColumn = pos.col;
        } else {
          endLine = end.line;
          endColumn = end.column;
        }
      } else if (!column) {
        let pos = this.fromOffset(line);
        line = pos.line;
        column = pos.col;
      }
      let origin = this.origin(line, column, endLine, endColumn);
      if (origin) {
        result2 = new CssSyntaxError$1(
          message,
          origin.endLine === void 0 ? origin.line : { column: origin.column, line: origin.line },
          origin.endLine === void 0 ? origin.column : { column: origin.endColumn, line: origin.endLine },
          origin.source,
          origin.file,
          opts.plugin
        );
      } else {
        result2 = new CssSyntaxError$1(
          message,
          endLine === void 0 ? line : { column, line },
          endLine === void 0 ? column : { column: endColumn, line: endLine },
          this.css,
          this.file,
          opts.plugin
        );
      }
      result2.input = { column, endColumn, endLine, line, source: this.css };
      if (this.file) {
        if (pathToFileURL$1) {
          result2.input.url = pathToFileURL$1(this.file).toString();
        }
        result2.input.file = this.file;
      }
      return result2;
    }
    fromOffset(offset) {
      let lastLine, lineToIndex;
      if (!this[fromOffsetCache]) {
        let lines = this.css.split("\n");
        lineToIndex = new Array(lines.length);
        let prevIndex = 0;
        for (let i2 = 0, l2 = lines.length; i2 < l2; i2++) {
          lineToIndex[i2] = prevIndex;
          prevIndex += lines[i2].length + 1;
        }
        this[fromOffsetCache] = lineToIndex;
      } else {
        lineToIndex = this[fromOffsetCache];
      }
      lastLine = lineToIndex[lineToIndex.length - 1];
      let min = 0;
      if (offset >= lastLine) {
        min = lineToIndex.length - 1;
      } else {
        let max = lineToIndex.length - 2;
        let mid;
        while (min < max) {
          mid = min + (max - min >> 1);
          if (offset < lineToIndex[mid]) {
            max = mid - 1;
          } else if (offset >= lineToIndex[mid + 1]) {
            min = mid + 1;
          } else {
            min = mid;
            break;
          }
        }
      }
      return {
        col: offset - lineToIndex[min] + 1,
        line: min + 1
      };
    }
    mapResolve(file) {
      if (/^\w+:\/\//.test(file)) {
        return file;
      }
      return resolve$1(this.map.consumer().sourceRoot || this.map.root || ".", file);
    }
    origin(line, column, endLine, endColumn) {
      if (!this.map) return false;
      let consumer = this.map.consumer();
      let from = consumer.originalPositionFor({ column, line });
      if (!from.source) return false;
      let to;
      if (typeof endLine === "number") {
        to = consumer.originalPositionFor({ column: endColumn, line: endLine });
      }
      let fromUrl;
      if (isAbsolute(from.source)) {
        fromUrl = pathToFileURL$1(from.source);
      } else {
        fromUrl = new URL(
          from.source,
          this.map.consumer().sourceRoot || pathToFileURL$1(this.map.mapFile)
        );
      }
      let result2 = {
        column: from.column,
        endColumn: to && to.column,
        endLine: to && to.line,
        line: from.line,
        url: fromUrl.toString()
      };
      if (fromUrl.protocol === "file:") {
        if (fileURLToPath) {
          result2.file = fileURLToPath(fromUrl);
        } else {
          throw new Error(`file: protocol is not available in this PostCSS build`);
        }
      }
      let source = consumer.sourceContentFor(from.source);
      if (source) result2.source = source;
      return result2;
    }
    toJSON() {
      let json = {};
      for (let name of ["hasBOM", "css", "file", "id"]) {
        if (this[name] != null) {
          json[name] = this[name];
        }
      }
      if (this.map) {
        json.map = { ...this.map };
        if (json.map.consumerCache) {
          json.map.consumerCache = void 0;
        }
      }
      return json;
    }
    get from() {
      return this.file || this.id;
    }
  };
  var input = Input$4;
  Input$4.default = Input$4;
  if (terminalHighlight && terminalHighlight.registerInput) {
    terminalHighlight.registerInput(Input$4);
  }
  var { SourceMapConsumer, SourceMapGenerator } = require$$2;
  var { dirname, relative, resolve, sep } = require$$2;
  var { pathToFileURL } = require$$2;
  var Input$3 = input;
  var sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator);
  var pathAvailable = Boolean(dirname && resolve && relative && sep);
  var MapGenerator$2 = class MapGenerator2 {
    constructor(stringify22, root2, opts, cssString) {
      this.stringify = stringify22;
      this.mapOpts = opts.map || {};
      this.root = root2;
      this.opts = opts;
      this.css = cssString;
      this.originalCSS = cssString;
      this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute;
      this.memoizedFileURLs = /* @__PURE__ */ new Map();
      this.memoizedPaths = /* @__PURE__ */ new Map();
      this.memoizedURLs = /* @__PURE__ */ new Map();
    }
    addAnnotation() {
      let content;
      if (this.isInline()) {
        content = "data:application/json;base64," + this.toBase64(this.map.toString());
      } else if (typeof this.mapOpts.annotation === "string") {
        content = this.mapOpts.annotation;
      } else if (typeof this.mapOpts.annotation === "function") {
        content = this.mapOpts.annotation(this.opts.to, this.root);
      } else {
        content = this.outputFile() + ".map";
      }
      let eol = "\n";
      if (this.css.includes("\r\n")) eol = "\r\n";
      this.css += eol + "/*# sourceMappingURL=" + content + " */";
    }
    applyPrevMaps() {
      for (let prev of this.previous()) {
        let from = this.toUrl(this.path(prev.file));
        let root2 = prev.root || dirname(prev.file);
        let map;
        if (this.mapOpts.sourcesContent === false) {
          map = new SourceMapConsumer(prev.text);
          if (map.sourcesContent) {
            map.sourcesContent = null;
          }
        } else {
          map = prev.consumer();
        }
        this.map.applySourceMap(map, from, this.toUrl(this.path(root2)));
      }
    }
    clearAnnotation() {
      if (this.mapOpts.annotation === false) return;
      if (this.root) {
        let node2;
        for (let i2 = this.root.nodes.length - 1; i2 >= 0; i2--) {
          node2 = this.root.nodes[i2];
          if (node2.type !== "comment") continue;
          if (node2.text.indexOf("# sourceMappingURL=") === 0) {
            this.root.removeChild(i2);
          }
        }
      } else if (this.css) {
        this.css = this.css.replace(/\n*?\/\*#[\S\s]*?\*\/$/gm, "");
      }
    }
    generate() {
      this.clearAnnotation();
      if (pathAvailable && sourceMapAvailable && this.isMap()) {
        return this.generateMap();
      } else {
        let result2 = "";
        this.stringify(this.root, (i2) => {
          result2 += i2;
        });
        return [result2];
      }
    }
    generateMap() {
      if (this.root) {
        this.generateString();
      } else if (this.previous().length === 1) {
        let prev = this.previous()[0].consumer();
        prev.file = this.outputFile();
        this.map = SourceMapGenerator.fromSourceMap(prev, {
          ignoreInvalidMapping: true
        });
      } else {
        this.map = new SourceMapGenerator({
          file: this.outputFile(),
          ignoreInvalidMapping: true
        });
        this.map.addMapping({
          generated: { column: 0, line: 1 },
          original: { column: 0, line: 1 },
          source: this.opts.from ? this.toUrl(this.path(this.opts.from)) : "<no source>"
        });
      }
      if (this.isSourcesContent()) this.setSourcesContent();
      if (this.root && this.previous().length > 0) this.applyPrevMaps();
      if (this.isAnnotation()) this.addAnnotation();
      if (this.isInline()) {
        return [this.css];
      } else {
        return [this.css, this.map];
      }
    }
    generateString() {
      this.css = "";
      this.map = new SourceMapGenerator({
        file: this.outputFile(),
        ignoreInvalidMapping: true
      });
      let line = 1;
      let column = 1;
      let noSource = "<no source>";
      let mapping = {
        generated: { column: 0, line: 0 },
        original: { column: 0, line: 0 },
        source: ""
      };
      let lines, last;
      this.stringify(this.root, (str, node2, type) => {
        this.css += str;
        if (node2 && type !== "end") {
          mapping.generated.line = line;
          mapping.generated.column = column - 1;
          if (node2.source && node2.source.start) {
            mapping.source = this.sourcePath(node2);
            mapping.original.line = node2.source.start.line;
            mapping.original.column = node2.source.start.column - 1;
            this.map.addMapping(mapping);
          } else {
            mapping.source = noSource;
            mapping.original.line = 1;
            mapping.original.column = 0;
            this.map.addMapping(mapping);
          }
        }
        lines = str.match(/\n/g);
        if (lines) {
          line += lines.length;
          last = str.lastIndexOf("\n");
          column = str.length - last;
        } else {
          column += str.length;
        }
        if (node2 && type !== "start") {
          let p = node2.parent || { raws: {} };
          let childless = node2.type === "decl" || node2.type === "atrule" && !node2.nodes;
          if (!childless || node2 !== p.last || p.raws.semicolon) {
            if (node2.source && node2.source.end) {
              mapping.source = this.sourcePath(node2);
              mapping.original.line = node2.source.end.line;
              mapping.original.column = node2.source.end.column - 1;
              mapping.generated.line = line;
              mapping.generated.column = column - 2;
              this.map.addMapping(mapping);
            } else {
              mapping.source = noSource;
              mapping.original.line = 1;
              mapping.original.column = 0;
              mapping.generated.line = line;
              mapping.generated.column = column - 1;
              this.map.addMapping(mapping);
            }
          }
        }
      });
    }
    isAnnotation() {
      if (this.isInline()) {
        return true;
      }
      if (typeof this.mapOpts.annotation !== "undefined") {
        return this.mapOpts.annotation;
      }
      if (this.previous().length) {
        return this.previous().some((i2) => i2.annotation);
      }
      return true;
    }
    isInline() {
      if (typeof this.mapOpts.inline !== "undefined") {
        return this.mapOpts.inline;
      }
      let annotation = this.mapOpts.annotation;
      if (typeof annotation !== "undefined" && annotation !== true) {
        return false;
      }
      if (this.previous().length) {
        return this.previous().some((i2) => i2.inline);
      }
      return true;
    }
    isMap() {
      if (typeof this.opts.map !== "undefined") {
        return !!this.opts.map;
      }
      return this.previous().length > 0;
    }
    isSourcesContent() {
      if (typeof this.mapOpts.sourcesContent !== "undefined") {
        return this.mapOpts.sourcesContent;
      }
      if (this.previous().length) {
        return this.previous().some((i2) => i2.withContent());
      }
      return true;
    }
    outputFile() {
      if (this.opts.to) {
        return this.path(this.opts.to);
      } else if (this.opts.from) {
        return this.path(this.opts.from);
      } else {
        return "to.css";
      }
    }
    path(file) {
      if (this.mapOpts.absolute) return file;
      if (file.charCodeAt(0) === 60) return file;
      if (/^\w+:\/\//.test(file)) return file;
      let cached = this.memoizedPaths.get(file);
      if (cached) return cached;
      let from = this.opts.to ? dirname(this.opts.to) : ".";
      if (typeof this.mapOpts.annotation === "string") {
        from = dirname(resolve(from, this.mapOpts.annotation));
      }
      let path = relative(from, file);
      this.memoizedPaths.set(file, path);
      return path;
    }
    previous() {
      if (!this.previousMaps) {
        this.previousMaps = [];
        if (this.root) {
          this.root.walk((node2) => {
            if (node2.source && node2.source.input.map) {
              let map = node2.source.input.map;
              if (!this.previousMaps.includes(map)) {
                this.previousMaps.push(map);
              }
            }
          });
        } else {
          let input2 = new Input$3(this.originalCSS, this.opts);
          if (input2.map) this.previousMaps.push(input2.map);
        }
      }
      return this.previousMaps;
    }
    setSourcesContent() {
      let already = {};
      if (this.root) {
        this.root.walk((node2) => {
          if (node2.source) {
            let from = node2.source.input.from;
            if (from && !already[from]) {
              already[from] = true;
              let fromUrl = this.usesFileUrls ? this.toFileUrl(from) : this.toUrl(this.path(from));
              this.map.setSourceContent(fromUrl, node2.source.input.css);
            }
          }
        });
      } else if (this.css) {
        let from = this.opts.from ? this.toUrl(this.path(this.opts.from)) : "<no source>";
        this.map.setSourceContent(from, this.css);
      }
    }
    sourcePath(node2) {
      if (this.mapOpts.from) {
        return this.toUrl(this.mapOpts.from);
      } else if (this.usesFileUrls) {
        return this.toFileUrl(node2.source.input.from);
      } else {
        return this.toUrl(this.path(node2.source.input.from));
      }
    }
    toBase64(str) {
      if (Buffer) {
        return Buffer.from(str).toString("base64");
      } else {
        return window.btoa(unescape(encodeURIComponent(str)));
      }
    }
    toFileUrl(path) {
      let cached = this.memoizedFileURLs.get(path);
      if (cached) return cached;
      if (pathToFileURL) {
        let fileURL = pathToFileURL(path).toString();
        this.memoizedFileURLs.set(path, fileURL);
        return fileURL;
      } else {
        throw new Error(
          "`map.absolute` option is not available in this PostCSS build"
        );
      }
    }
    toUrl(path) {
      let cached = this.memoizedURLs.get(path);
      if (cached) return cached;
      if (sep === "\\") {
        path = path.replace(/\\/g, "/");
      }
      let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent);
      this.memoizedURLs.set(path, url);
      return url;
    }
  };
  var mapGenerator = MapGenerator$2;
  var Node$2 = node;
  var Comment$4 = class Comment2 extends Node$2 {
    constructor(defaults) {
      super(defaults);
      this.type = "comment";
    }
  };
  var comment = Comment$4;
  Comment$4.default = Comment$4;
  var { isClean: isClean$1, my: my$1 } = symbols;
  var Declaration$3 = declaration;
  var Comment$3 = comment;
  var Node$1 = node;
  var parse$4;
  var Rule$4;
  var AtRule$4;
  var Root$6;
  function cleanSource(nodes) {
    return nodes.map((i2) => {
      if (i2.nodes) i2.nodes = cleanSource(i2.nodes);
      delete i2.source;
      return i2;
    });
  }
  function markDirtyUp(node2) {
    node2[isClean$1] = false;
    if (node2.proxyOf.nodes) {
      for (let i2 of node2.proxyOf.nodes) {
        markDirtyUp(i2);
      }
    }
  }
  var Container$7 = class Container2 extends Node$1 {
    append(...children) {
      for (let child of children) {
        let nodes = this.normalize(child, this.last);
        for (let node2 of nodes) this.proxyOf.nodes.push(node2);
      }
      this.markDirty();
      return this;
    }
    cleanRaws(keepBetween) {
      super.cleanRaws(keepBetween);
      if (this.nodes) {
        for (let node2 of this.nodes) node2.cleanRaws(keepBetween);
      }
    }
    each(callback) {
      if (!this.proxyOf.nodes) return void 0;
      let iterator = this.getIterator();
      let index2, result2;
      while (this.indexes[iterator] < this.proxyOf.nodes.length) {
        index2 = this.indexes[iterator];
        result2 = callback(this.proxyOf.nodes[index2], index2);
        if (result2 === false) break;
        this.indexes[iterator] += 1;
      }
      delete this.indexes[iterator];
      return result2;
    }
    every(condition) {
      return this.nodes.every(condition);
    }
    getIterator() {
      if (!this.lastEach) this.lastEach = 0;
      if (!this.indexes) this.indexes = {};
      this.lastEach += 1;
      let iterator = this.lastEach;
      this.indexes[iterator] = 0;
      return iterator;
    }
    getProxyProcessor() {
      return {
        get(node2, prop) {
          if (prop === "proxyOf") {
            return node2;
          } else if (!node2[prop]) {
            return node2[prop];
          } else if (prop === "each" || typeof prop === "string" && prop.startsWith("walk")) {
            return (...args) => {
              return node2[prop](
                ...args.map((i2) => {
                  if (typeof i2 === "function") {
                    return (child, index2) => i2(child.toProxy(), index2);
                  } else {
                    return i2;
                  }
                })
              );
            };
          } else if (prop === "every" || prop === "some") {
            return (cb) => {
              return node2[prop](
                (child, ...other) => cb(child.toProxy(), ...other)
              );
            };
          } else if (prop === "root") {
            return () => node2.root().toProxy();
          } else if (prop === "nodes") {
            return node2.nodes.map((i2) => i2.toProxy());
          } else if (prop === "first" || prop === "last") {
            return node2[prop].toProxy();
          } else {
            return node2[prop];
          }
        },
        set(node2, prop, value) {
          if (node2[prop] === value) return true;
          node2[prop] = value;
          if (prop === "name" || prop === "params" || prop === "selector") {
            node2.markDirty();
          }
          return true;
        }
      };
    }
    index(child) {
      if (typeof child === "number") return child;
      if (child.proxyOf) child = child.proxyOf;
      return this.proxyOf.nodes.indexOf(child);
    }
    insertAfter(exist, add) {
      let existIndex = this.index(exist);
      let nodes = this.normalize(add, this.proxyOf.nodes[existIndex]).reverse();
      existIndex = this.index(exist);
      for (let node2 of nodes) this.proxyOf.nodes.splice(existIndex + 1, 0, node2);
      let index2;
      for (let id in this.indexes) {
        index2 = this.indexes[id];
        if (existIndex < index2) {
          this.indexes[id] = index2 + nodes.length;
        }
      }
      this.markDirty();
      return this;
    }
    insertBefore(exist, add) {
      let existIndex = this.index(exist);
      let type = existIndex === 0 ? "prepend" : false;
      let nodes = this.normalize(add, this.proxyOf.nodes[existIndex], type).reverse();
      existIndex = this.index(exist);
      for (let node2 of nodes) this.proxyOf.nodes.splice(existIndex, 0, node2);
      let index2;
      for (let id in this.indexes) {
        index2 = this.indexes[id];
        if (existIndex <= index2) {
          this.indexes[id] = index2 + nodes.length;
        }
      }
      this.markDirty();
      return this;
    }
    normalize(nodes, sample) {
      if (typeof nodes === "string") {
        nodes = cleanSource(parse$4(nodes).nodes);
      } else if (typeof nodes === "undefined") {
        nodes = [];
      } else if (Array.isArray(nodes)) {
        nodes = nodes.slice(0);
        for (let i2 of nodes) {
          if (i2.parent) i2.parent.removeChild(i2, "ignore");
        }
      } else if (nodes.type === "root" && this.type !== "document") {
        nodes = nodes.nodes.slice(0);
        for (let i2 of nodes) {
          if (i2.parent) i2.parent.removeChild(i2, "ignore");
        }
      } else if (nodes.type) {
        nodes = [nodes];
      } else if (nodes.prop) {
        if (typeof nodes.value === "undefined") {
          throw new Error("Value field is missed in node creation");
        } else if (typeof nodes.value !== "string") {
          nodes.value = String(nodes.value);
        }
        nodes = [new Declaration$3(nodes)];
      } else if (nodes.selector) {
        nodes = [new Rule$4(nodes)];
      } else if (nodes.name) {
        nodes = [new AtRule$4(nodes)];
      } else if (nodes.text) {
        nodes = [new Comment$3(nodes)];
      } else {
        throw new Error("Unknown node type in node creation");
      }
      let processed = nodes.map((i2) => {
        if (!i2[my$1]) Container2.rebuild(i2);
        i2 = i2.proxyOf;
        if (i2.parent) i2.parent.removeChild(i2);
        if (i2[isClean$1]) markDirtyUp(i2);
        if (typeof i2.raws.before === "undefined") {
          if (sample && typeof sample.raws.before !== "undefined") {
            i2.raws.before = sample.raws.before.replace(/\S/g, "");
          }
        }
        i2.parent = this.proxyOf;
        return i2;
      });
      return processed;
    }
    prepend(...children) {
      children = children.reverse();
      for (let child of children) {
        let nodes = this.normalize(child, this.first, "prepend").reverse();
        for (let node2 of nodes) this.proxyOf.nodes.unshift(node2);
        for (let id in this.indexes) {
          this.indexes[id] = this.indexes[id] + nodes.length;
        }
      }
      this.markDirty();
      return this;
    }
    push(child) {
      child.parent = this;
      this.proxyOf.nodes.push(child);
      return this;
    }
    removeAll() {
      for (let node2 of this.proxyOf.nodes) node2.parent = void 0;
      this.proxyOf.nodes = [];
      this.markDirty();
      return this;
    }
    removeChild(child) {
      child = this.index(child);
      this.proxyOf.nodes[child].parent = void 0;
      this.proxyOf.nodes.splice(child, 1);
      let index2;
      for (let id in this.indexes) {
        index2 = this.indexes[id];
        if (index2 >= child) {
          this.indexes[id] = index2 - 1;
        }
      }
      this.markDirty();
      return this;
    }
    replaceValues(pattern, opts, callback) {
      if (!callback) {
        callback = opts;
        opts = {};
      }
      this.walkDecls((decl) => {
        if (opts.props && !opts.props.includes(decl.prop)) return;
        if (opts.fast && !decl.value.includes(opts.fast)) return;
        decl.value = decl.value.replace(pattern, callback);
      });
      this.markDirty();
      return this;
    }
    some(condition) {
      return this.nodes.some(condition);
    }
    walk(callback) {
      return this.each((child, i2) => {
        let result2;
        try {
          result2 = callback(child, i2);
        } catch (e2) {
          throw child.addToError(e2);
        }
        if (result2 !== false && child.walk) {
          result2 = child.walk(callback);
        }
        return result2;
      });
    }
    walkAtRules(name, callback) {
      if (!callback) {
        callback = name;
        return this.walk((child, i2) => {
          if (child.type === "atrule") {
            return callback(child, i2);
          }
        });
      }
      if (name instanceof RegExp) {
        return this.walk((child, i2) => {
          if (child.type === "atrule" && name.test(child.name)) {
            return callback(child, i2);
          }
        });
      }
      return this.walk((child, i2) => {
        if (child.type === "atrule" && child.name === name) {
          return callback(child, i2);
        }
      });
    }
    walkComments(callback) {
      return this.walk((child, i2) => {
        if (child.type === "comment") {
          return callback(child, i2);
        }
      });
    }
    walkDecls(prop, callback) {
      if (!callback) {
        callback = prop;
        return this.walk((child, i2) => {
          if (child.type === "decl") {
            return callback(child, i2);
          }
        });
      }
      if (prop instanceof RegExp) {
        return this.walk((child, i2) => {
          if (child.type === "decl" && prop.test(child.prop)) {
            return callback(child, i2);
          }
        });
      }
      return this.walk((child, i2) => {
        if (child.type === "decl" && child.prop === prop) {
          return callback(child, i2);
        }
      });
    }
    walkRules(selector, callback) {
      if (!callback) {
        callback = selector;
        return this.walk((child, i2) => {
          if (child.type === "rule") {
            return callback(child, i2);
          }
        });
      }
      if (selector instanceof RegExp) {
        return this.walk((child, i2) => {
          if (child.type === "rule" && selector.test(child.selector)) {
            return callback(child, i2);
          }
        });
      }
      return this.walk((child, i2) => {
        if (child.type === "rule" && child.selector === selector) {
          return callback(child, i2);
        }
      });
    }
    get first() {
      if (!this.proxyOf.nodes) return void 0;
      return this.proxyOf.nodes[0];
    }
    get last() {
      if (!this.proxyOf.nodes) return void 0;
      return this.proxyOf.nodes[this.proxyOf.nodes.length - 1];
    }
  };
  Container$7.registerParse = (dependant) => {
    parse$4 = dependant;
  };
  Container$7.registerRule = (dependant) => {
    Rule$4 = dependant;
  };
  Container$7.registerAtRule = (dependant) => {
    AtRule$4 = dependant;
  };
  Container$7.registerRoot = (dependant) => {
    Root$6 = dependant;
  };
  var container = Container$7;
  Container$7.default = Container$7;
  Container$7.rebuild = (node2) => {
    if (node2.type === "atrule") {
      Object.setPrototypeOf(node2, AtRule$4.prototype);
    } else if (node2.type === "rule") {
      Object.setPrototypeOf(node2, Rule$4.prototype);
    } else if (node2.type === "decl") {
      Object.setPrototypeOf(node2, Declaration$3.prototype);
    } else if (node2.type === "comment") {
      Object.setPrototypeOf(node2, Comment$3.prototype);
    } else if (node2.type === "root") {
      Object.setPrototypeOf(node2, Root$6.prototype);
    }
    node2[my$1] = true;
    if (node2.nodes) {
      node2.nodes.forEach((child) => {
        Container$7.rebuild(child);
      });
    }
  };
  var Container$6 = container;
  var LazyResult$4;
  var Processor$3;
  var Document$3 = class Document23 extends Container$6 {
    constructor(defaults) {
      super({ type: "document", ...defaults });
      if (!this.nodes) {
        this.nodes = [];
      }
    }
    toResult(opts = {}) {
      let lazy = new LazyResult$4(new Processor$3(), this, opts);
      return lazy.stringify();
    }
  };
  Document$3.registerLazyResult = (dependant) => {
    LazyResult$4 = dependant;
  };
  Document$3.registerProcessor = (dependant) => {
    Processor$3 = dependant;
  };
  var document$1 = Document$3;
  Document$3.default = Document$3;
  var printed = {};
  var warnOnce$2 = function warnOnce2(message) {
    if (printed[message]) return;
    printed[message] = true;
    if (typeof console !== "undefined" && console.warn) {
      console.warn(message);
    }
  };
  var Warning$2 = class Warning2 {
    constructor(text, opts = {}) {
      this.type = "warning";
      this.text = text;
      if (opts.node && opts.node.source) {
        let range = opts.node.rangeBy(opts);
        this.line = range.start.line;
        this.column = range.start.column;
        this.endLine = range.end.line;
        this.endColumn = range.end.column;
      }
      for (let opt in opts) this[opt] = opts[opt];
    }
    toString() {
      if (this.node) {
        return this.node.error(this.text, {
          index: this.index,
          plugin: this.plugin,
          word: this.word
        }).message;
      }
      if (this.plugin) {
        return this.plugin + ": " + this.text;
      }
      return this.text;
    }
  };
  var warning = Warning$2;
  Warning$2.default = Warning$2;
  var Warning$1 = warning;
  var Result$3 = class Result2 {
    constructor(processor2, root2, opts) {
      this.processor = processor2;
      this.messages = [];
      this.root = root2;
      this.opts = opts;
      this.css = void 0;
      this.map = void 0;
    }
    toString() {
      return this.css;
    }
    warn(text, opts = {}) {
      if (!opts.plugin) {
        if (this.lastPlugin && this.lastPlugin.postcssPlugin) {
          opts.plugin = this.lastPlugin.postcssPlugin;
        }
      }
      let warning2 = new Warning$1(text, opts);
      this.messages.push(warning2);
      return warning2;
    }
    warnings() {
      return this.messages.filter((i2) => i2.type === "warning");
    }
    get content() {
      return this.css;
    }
  };
  var result = Result$3;
  Result$3.default = Result$3;
  var SINGLE_QUOTE = "'".charCodeAt(0);
  var DOUBLE_QUOTE = '"'.charCodeAt(0);
  var BACKSLASH = "\\".charCodeAt(0);
  var SLASH = "/".charCodeAt(0);
  var NEWLINE = "\n".charCodeAt(0);
  var SPACE = " ".charCodeAt(0);
  var FEED = "\f".charCodeAt(0);
  var TAB = "	".charCodeAt(0);
  var CR = "\r".charCodeAt(0);
  var OPEN_SQUARE = "[".charCodeAt(0);
  var CLOSE_SQUARE = "]".charCodeAt(0);
  var OPEN_PARENTHESES = "(".charCodeAt(0);
  var CLOSE_PARENTHESES = ")".charCodeAt(0);
  var OPEN_CURLY = "{".charCodeAt(0);
  var CLOSE_CURLY = "}".charCodeAt(0);
  var SEMICOLON = ";".charCodeAt(0);
  var ASTERISK = "*".charCodeAt(0);
  var COLON = ":".charCodeAt(0);
  var AT = "@".charCodeAt(0);
  var RE_AT_END = /[\t\n\f\r "#'()/;[\\\]{}]/g;
  var RE_WORD_END = /[\t\n\f\r !"#'():;@[\\\]{}]|\/(?=\*)/g;
  var RE_BAD_BRACKET = /.[\r\n"'(/\\]/;
  var RE_HEX_ESCAPE = /[\da-f]/i;
  var tokenize = function tokenizer2(input2, options = {}) {
    let css = input2.css.valueOf();
    let ignore = options.ignoreErrors;
    let code, next, quote, content, escape;
    let escaped, escapePos, prev, n2, currentToken;
    let length = css.length;
    let pos = 0;
    let buffer = [];
    let returned = [];
    function position() {
      return pos;
    }
    function unclosed(what) {
      throw input2.error("Unclosed " + what, pos);
    }
    function endOfFile() {
      return returned.length === 0 && pos >= length;
    }
    function nextToken(opts) {
      if (returned.length) return returned.pop();
      if (pos >= length) return;
      let ignoreUnclosed = opts ? opts.ignoreUnclosed : false;
      code = css.charCodeAt(pos);
      switch (code) {
        case NEWLINE:
        case SPACE:
        case TAB:
        case CR:
        case FEED: {
          next = pos;
          do {
            next += 1;
            code = css.charCodeAt(next);
          } while (code === SPACE || code === NEWLINE || code === TAB || code === CR || code === FEED);
          currentToken = ["space", css.slice(pos, next)];
          pos = next - 1;
          break;
        }
        case OPEN_SQUARE:
        case CLOSE_SQUARE:
        case OPEN_CURLY:
        case CLOSE_CURLY:
        case COLON:
        case SEMICOLON:
        case CLOSE_PARENTHESES: {
          let controlChar = String.fromCharCode(code);
          currentToken = [controlChar, controlChar, pos];
          break;
        }
        case OPEN_PARENTHESES: {
          prev = buffer.length ? buffer.pop()[1] : "";
          n2 = css.charCodeAt(pos + 1);
          if (prev === "url" && n2 !== SINGLE_QUOTE && n2 !== DOUBLE_QUOTE && n2 !== SPACE && n2 !== NEWLINE && n2 !== TAB && n2 !== FEED && n2 !== CR) {
            next = pos;
            do {
              escaped = false;
              next = css.indexOf(")", next + 1);
              if (next === -1) {
                if (ignore || ignoreUnclosed) {
                  next = pos;
                  break;
                } else {
                  unclosed("bracket");
                }
              }
              escapePos = next;
              while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
                escapePos -= 1;
                escaped = !escaped;
              }
            } while (escaped);
            currentToken = ["brackets", css.slice(pos, next + 1), pos, next];
            pos = next;
          } else {
            next = css.indexOf(")", pos + 1);
            content = css.slice(pos, next + 1);
            if (next === -1 || RE_BAD_BRACKET.test(content)) {
              currentToken = ["(", "(", pos];
            } else {
              currentToken = ["brackets", content, pos, next];
              pos = next;
            }
          }
          break;
        }
        case SINGLE_QUOTE:
        case DOUBLE_QUOTE: {
          quote = code === SINGLE_QUOTE ? "'" : '"';
          next = pos;
          do {
            escaped = false;
            next = css.indexOf(quote, next + 1);
            if (next === -1) {
              if (ignore || ignoreUnclosed) {
                next = pos + 1;
                break;
              } else {
                unclosed("string");
              }
            }
            escapePos = next;
            while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
              escapePos -= 1;
              escaped = !escaped;
            }
          } while (escaped);
          currentToken = ["string", css.slice(pos, next + 1), pos, next];
          pos = next;
          break;
        }
        case AT: {
          RE_AT_END.lastIndex = pos + 1;
          RE_AT_END.test(css);
          if (RE_AT_END.lastIndex === 0) {
            next = css.length - 1;
          } else {
            next = RE_AT_END.lastIndex - 2;
          }
          currentToken = ["at-word", css.slice(pos, next + 1), pos, next];
          pos = next;
          break;
        }
        case BACKSLASH: {
          next = pos;
          escape = true;
          while (css.charCodeAt(next + 1) === BACKSLASH) {
            next += 1;
            escape = !escape;
          }
          code = css.charCodeAt(next + 1);
          if (escape && code !== SLASH && code !== SPACE && code !== NEWLINE && code !== TAB && code !== CR && code !== FEED) {
            next += 1;
            if (RE_HEX_ESCAPE.test(css.charAt(next))) {
              while (RE_HEX_ESCAPE.test(css.charAt(next + 1))) {
                next += 1;
              }
              if (css.charCodeAt(next + 1) === SPACE) {
                next += 1;
              }
            }
          }
          currentToken = ["word", css.slice(pos, next + 1), pos, next];
          pos = next;
          break;
        }
        default: {
          if (code === SLASH && css.charCodeAt(pos + 1) === ASTERISK) {
            next = css.indexOf("*/", pos + 2) + 1;
            if (next === 0) {
              if (ignore || ignoreUnclosed) {
                next = css.length;
              } else {
                unclosed("comment");
              }
            }
            currentToken = ["comment", css.slice(pos, next + 1), pos, next];
            pos = next;
          } else {
            RE_WORD_END.lastIndex = pos + 1;
            RE_WORD_END.test(css);
            if (RE_WORD_END.lastIndex === 0) {
              next = css.length - 1;
            } else {
              next = RE_WORD_END.lastIndex - 2;
            }
            currentToken = ["word", css.slice(pos, next + 1), pos, next];
            buffer.push(currentToken);
            pos = next;
          }
          break;
        }
      }
      pos++;
      return currentToken;
    }
    function back(token) {
      returned.push(token);
    }
    return {
      back,
      endOfFile,
      nextToken,
      position
    };
  };
  var Container$5 = container;
  var AtRule$3 = class AtRule2 extends Container$5 {
    constructor(defaults) {
      super(defaults);
      this.type = "atrule";
    }
    append(...children) {
      if (!this.proxyOf.nodes) this.nodes = [];
      return super.append(...children);
    }
    prepend(...children) {
      if (!this.proxyOf.nodes) this.nodes = [];
      return super.prepend(...children);
    }
  };
  var atRule = AtRule$3;
  AtRule$3.default = AtRule$3;
  Container$5.registerAtRule(AtRule$3);
  var Container$4 = container;
  var LazyResult$3;
  var Processor$2;
  var Root$5 = class Root2 extends Container$4 {
    constructor(defaults) {
      super(defaults);
      this.type = "root";
      if (!this.nodes) this.nodes = [];
    }
    normalize(child, sample, type) {
      let nodes = super.normalize(child);
      if (sample) {
        if (type === "prepend") {
          if (this.nodes.length > 1) {
            sample.raws.before = this.nodes[1].raws.before;
          } else {
            delete sample.raws.before;
          }
        } else if (this.first !== sample) {
          for (let node2 of nodes) {
            node2.raws.before = sample.raws.before;
          }
        }
      }
      return nodes;
    }
    removeChild(child, ignore) {
      let index2 = this.index(child);
      if (!ignore && index2 === 0 && this.nodes.length > 1) {
        this.nodes[1].raws.before = this.nodes[index2].raws.before;
      }
      return super.removeChild(child);
    }
    toResult(opts = {}) {
      let lazy = new LazyResult$3(new Processor$2(), this, opts);
      return lazy.stringify();
    }
  };
  Root$5.registerLazyResult = (dependant) => {
    LazyResult$3 = dependant;
  };
  Root$5.registerProcessor = (dependant) => {
    Processor$2 = dependant;
  };
  var root = Root$5;
  Root$5.default = Root$5;
  Container$4.registerRoot(Root$5);
  var list$2 = {
    comma(string) {
      return list$2.split(string, [","], true);
    },
    space(string) {
      let spaces = [" ", "\n", "	"];
      return list$2.split(string, spaces);
    },
    split(string, separators, last) {
      let array = [];
      let current = "";
      let split = false;
      let func = 0;
      let inQuote = false;
      let prevQuote = "";
      let escape = false;
      for (let letter of string) {
        if (escape) {
          escape = false;
        } else if (letter === "\\") {
          escape = true;
        } else if (inQuote) {
          if (letter === prevQuote) {
            inQuote = false;
          }
        } else if (letter === '"' || letter === "'") {
          inQuote = true;
          prevQuote = letter;
        } else if (letter === "(") {
          func += 1;
        } else if (letter === ")") {
          if (func > 0) func -= 1;
        } else if (func === 0) {
          if (separators.includes(letter)) split = true;
        }
        if (split) {
          if (current !== "") array.push(current.trim());
          current = "";
          split = false;
        } else {
          current += letter;
        }
      }
      if (last || current !== "") array.push(current.trim());
      return array;
    }
  };
  var list_1 = list$2;
  list$2.default = list$2;
  var Container$3 = container;
  var list$1 = list_1;
  var Rule$3 = class Rule2 extends Container$3 {
    constructor(defaults) {
      super(defaults);
      this.type = "rule";
      if (!this.nodes) this.nodes = [];
    }
    get selectors() {
      return list$1.comma(this.selector);
    }
    set selectors(values) {
      let match = this.selector ? this.selector.match(/,\s*/) : null;
      let sep2 = match ? match[0] : "," + this.raw("between", "beforeOpen");
      this.selector = values.join(sep2);
    }
  };
  var rule = Rule$3;
  Rule$3.default = Rule$3;
  Container$3.registerRule(Rule$3);
  var Declaration$2 = declaration;
  var tokenizer22 = tokenize;
  var Comment$2 = comment;
  var AtRule$2 = atRule;
  var Root$4 = root;
  var Rule$2 = rule;
  var SAFE_COMMENT_NEIGHBOR = {
    empty: true,
    space: true
  };
  function findLastWithPosition(tokens) {
    for (let i2 = tokens.length - 1; i2 >= 0; i2--) {
      let token = tokens[i2];
      let pos = token[3] || token[2];
      if (pos) return pos;
    }
  }
  var Parser$1 = class Parser2 {
    constructor(input2) {
      this.input = input2;
      this.root = new Root$4();
      this.current = this.root;
      this.spaces = "";
      this.semicolon = false;
      this.createTokenizer();
      this.root.source = { input: input2, start: { column: 1, line: 1, offset: 0 } };
    }
    atrule(token) {
      let node2 = new AtRule$2();
      node2.name = token[1].slice(1);
      if (node2.name === "") {
        this.unnamedAtrule(node2, token);
      }
      this.init(node2, token[2]);
      let type;
      let prev;
      let shift;
      let last = false;
      let open = false;
      let params = [];
      let brackets = [];
      while (!this.tokenizer.endOfFile()) {
        token = this.tokenizer.nextToken();
        type = token[0];
        if (type === "(" || type === "[") {
          brackets.push(type === "(" ? ")" : "]");
        } else if (type === "{" && brackets.length > 0) {
          brackets.push("}");
        } else if (type === brackets[brackets.length - 1]) {
          brackets.pop();
        }
        if (brackets.length === 0) {
          if (type === ";") {
            node2.source.end = this.getPosition(token[2]);
            node2.source.end.offset++;
            this.semicolon = true;
            break;
          } else if (type === "{") {
            open = true;
            break;
          } else if (type === "}") {
            if (params.length > 0) {
              shift = params.length - 1;
              prev = params[shift];
              while (prev && prev[0] === "space") {
                prev = params[--shift];
              }
              if (prev) {
                node2.source.end = this.getPosition(prev[3] || prev[2]);
                node2.source.end.offset++;
              }
            }
            this.end(token);
            break;
          } else {
            params.push(token);
          }
        } else {
          params.push(token);
        }
        if (this.tokenizer.endOfFile()) {
          last = true;
          break;
        }
      }
      node2.raws.between = this.spacesAndCommentsFromEnd(params);
      if (params.length) {
        node2.raws.afterName = this.spacesAndCommentsFromStart(params);
        this.raw(node2, "params", params);
        if (last) {
          token = params[params.length - 1];
          node2.source.end = this.getPosition(token[3] || token[2]);
          node2.source.end.offset++;
          this.spaces = node2.raws.between;
          node2.raws.between = "";
        }
      } else {
        node2.raws.afterName = "";
        node2.params = "";
      }
      if (open) {
        node2.nodes = [];
        this.current = node2;
      }
    }
    checkMissedSemicolon(tokens) {
      let colon = this.colon(tokens);
      if (colon === false) return;
      let founded = 0;
      let token;
      for (let j = colon - 1; j >= 0; j--) {
        token = tokens[j];
        if (token[0] !== "space") {
          founded += 1;
          if (founded === 2) break;
        }
      }
      throw this.input.error(
        "Missed semicolon",
        token[0] === "word" ? token[3] + 1 : token[2]
      );
    }
    colon(tokens) {
      let brackets = 0;
      let token, type, prev;
      for (let [i2, element] of tokens.entries()) {
        token = element;
        type = token[0];
        if (type === "(") {
          brackets += 1;
        }
        if (type === ")") {
          brackets -= 1;
        }
        if (brackets === 0 && type === ":") {
          if (!prev) {
            this.doubleColon(token);
          } else if (prev[0] === "word" && prev[1] === "progid") {
            continue;
          } else {
            return i2;
          }
        }
        prev = token;
      }
      return false;
    }
    comment(token) {
      let node2 = new Comment$2();
      this.init(node2, token[2]);
      node2.source.end = this.getPosition(token[3] || token[2]);
      node2.source.end.offset++;
      let text = token[1].slice(2, -2);
      if (/^\s*$/.test(text)) {
        node2.text = "";
        node2.raws.left = text;
        node2.raws.right = "";
      } else {
        let match = text.match(/^(\s*)([^]*\S)(\s*)$/);
        node2.text = match[2];
        node2.raws.left = match[1];
        node2.raws.right = match[3];
      }
    }
    createTokenizer() {
      this.tokenizer = tokenizer22(this.input);
    }
    decl(tokens, customProperty) {
      let node2 = new Declaration$2();
      this.init(node2, tokens[0][2]);
      let last = tokens[tokens.length - 1];
      if (last[0] === ";") {
        this.semicolon = true;
        tokens.pop();
      }
      node2.source.end = this.getPosition(
        last[3] || last[2] || findLastWithPosition(tokens)
      );
      node2.source.end.offset++;
      while (tokens[0][0] !== "word") {
        if (tokens.length === 1) this.unknownWord(tokens);
        node2.raws.before += tokens.shift()[1];
      }
      node2.source.start = this.getPosition(tokens[0][2]);
      node2.prop = "";
      while (tokens.length) {
        let type = tokens[0][0];
        if (type === ":" || type === "space" || type === "comment") {
          break;
        }
        node2.prop += tokens.shift()[1];
      }
      node2.raws.between = "";
      let token;
      while (tokens.length) {
        token = tokens.shift();
        if (token[0] === ":") {
          node2.raws.between += token[1];
          break;
        } else {
          if (token[0] === "word" && /\w/.test(token[1])) {
            this.unknownWord([token]);
          }
          node2.raws.between += token[1];
        }
      }
      if (node2.prop[0] === "_" || node2.prop[0] === "*") {
        node2.raws.before += node2.prop[0];
        node2.prop = node2.prop.slice(1);
      }
      let firstSpaces = [];
      let next;
      while (tokens.length) {
        next = tokens[0][0];
        if (next !== "space" && next !== "comment") break;
        firstSpaces.push(tokens.shift());
      }
      this.precheckMissedSemicolon(tokens);
      for (let i2 = tokens.length - 1; i2 >= 0; i2--) {
        token = tokens[i2];
        if (token[1].toLowerCase() === "!important") {
          node2.important = true;
          let string = this.stringFrom(tokens, i2);
          string = this.spacesFromEnd(tokens) + string;
          if (string !== " !important") node2.raws.important = string;
          break;
        } else if (token[1].toLowerCase() === "important") {
          let cache = tokens.slice(0);
          let str = "";
          for (let j = i2; j > 0; j--) {
            let type = cache[j][0];
            if (str.trim().indexOf("!") === 0 && type !== "space") {
              break;
            }
            str = cache.pop()[1] + str;
          }
          if (str.trim().indexOf("!") === 0) {
            node2.important = true;
            node2.raws.important = str;
            tokens = cache;
          }
        }
        if (token[0] !== "space" && token[0] !== "comment") {
          break;
        }
      }
      let hasWord = tokens.some((i2) => i2[0] !== "space" && i2[0] !== "comment");
      if (hasWord) {
        node2.raws.between += firstSpaces.map((i2) => i2[1]).join("");
        firstSpaces = [];
      }
      this.raw(node2, "value", firstSpaces.concat(tokens), customProperty);
      if (node2.value.includes(":") && !customProperty) {
        this.checkMissedSemicolon(tokens);
      }
    }
    doubleColon(token) {
      throw this.input.error(
        "Double colon",
        { offset: token[2] },
        { offset: token[2] + token[1].length }
      );
    }
    emptyRule(token) {
      let node2 = new Rule$2();
      this.init(node2, token[2]);
      node2.selector = "";
      node2.raws.between = "";
      this.current = node2;
    }
    end(token) {
      if (this.current.nodes && this.current.nodes.length) {
        this.current.raws.semicolon = this.semicolon;
      }
      this.semicolon = false;
      this.current.raws.after = (this.current.raws.after || "") + this.spaces;
      this.spaces = "";
      if (this.current.parent) {
        this.current.source.end = this.getPosition(token[2]);
        this.current.source.end.offset++;
        this.current = this.current.parent;
      } else {
        this.unexpectedClose(token);
      }
    }
    endFile() {
      if (this.current.parent) this.unclosedBlock();
      if (this.current.nodes && this.current.nodes.length) {
        this.current.raws.semicolon = this.semicolon;
      }
      this.current.raws.after = (this.current.raws.after || "") + this.spaces;
      this.root.source.end = this.getPosition(this.tokenizer.position());
    }
    freeSemicolon(token) {
      this.spaces += token[1];
      if (this.current.nodes) {
        let prev = this.current.nodes[this.current.nodes.length - 1];
        if (prev && prev.type === "rule" && !prev.raws.ownSemicolon) {
          prev.raws.ownSemicolon = this.spaces;
          this.spaces = "";
        }
      }
    }
    // Helpers
    getPosition(offset) {
      let pos = this.input.fromOffset(offset);
      return {
        column: pos.col,
        line: pos.line,
        offset
      };
    }
    init(node2, offset) {
      this.current.push(node2);
      node2.source = {
        input: this.input,
        start: this.getPosition(offset)
      };
      node2.raws.before = this.spaces;
      this.spaces = "";
      if (node2.type !== "comment") this.semicolon = false;
    }
    other(start) {
      let end = false;
      let type = null;
      let colon = false;
      let bracket = null;
      let brackets = [];
      let customProperty = start[1].startsWith("--");
      let tokens = [];
      let token = start;
      while (token) {
        type = token[0];
        tokens.push(token);
        if (type === "(" || type === "[") {
          if (!bracket) bracket = token;
          brackets.push(type === "(" ? ")" : "]");
        } else if (customProperty && colon && type === "{") {
          if (!bracket) bracket = token;
          brackets.push("}");
        } else if (brackets.length === 0) {
          if (type === ";") {
            if (colon) {
              this.decl(tokens, customProperty);
              return;
            } else {
              break;
            }
          } else if (type === "{") {
            this.rule(tokens);
            return;
          } else if (type === "}") {
            this.tokenizer.back(tokens.pop());
            end = true;
            break;
          } else if (type === ":") {
            colon = true;
          }
        } else if (type === brackets[brackets.length - 1]) {
          brackets.pop();
          if (brackets.length === 0) bracket = null;
        }
        token = this.tokenizer.nextToken();
      }
      if (this.tokenizer.endOfFile()) end = true;
      if (brackets.length > 0) this.unclosedBracket(bracket);
      if (end && colon) {
        if (!customProperty) {
          while (tokens.length) {
            token = tokens[tokens.length - 1][0];
            if (token !== "space" && token !== "comment") break;
            this.tokenizer.back(tokens.pop());
          }
        }
        this.decl(tokens, customProperty);
      } else {
        this.unknownWord(tokens);
      }
    }
    parse() {
      let token;
      while (!this.tokenizer.endOfFile()) {
        token = this.tokenizer.nextToken();
        switch (token[0]) {
          case "space":
            this.spaces += token[1];
            break;
          case ";":
            this.freeSemicolon(token);
            break;
          case "}":
            this.end(token);
            break;
          case "comment":
            this.comment(token);
            break;
          case "at-word":
            this.atrule(token);
            break;
          case "{":
            this.emptyRule(token);
            break;
          default:
            this.other(token);
            break;
        }
      }
      this.endFile();
    }
    precheckMissedSemicolon() {
    }
    raw(node2, prop, tokens, customProperty) {
      let token, type;
      let length = tokens.length;
      let value = "";
      let clean = true;
      let next, prev;
      for (let i2 = 0; i2 < length; i2 += 1) {
        token = tokens[i2];
        type = token[0];
        if (type === "space" && i2 === length - 1 && !customProperty) {
          clean = false;
        } else if (type === "comment") {
          prev = tokens[i2 - 1] ? tokens[i2 - 1][0] : "empty";
          next = tokens[i2 + 1] ? tokens[i2 + 1][0] : "empty";
          if (!SAFE_COMMENT_NEIGHBOR[prev] && !SAFE_COMMENT_NEIGHBOR[next]) {
            if (value.slice(-1) === ",") {
              clean = false;
            } else {
              value += token[1];
            }
          } else {
            clean = false;
          }
        } else {
          value += token[1];
        }
      }
      if (!clean) {
        let raw = tokens.reduce((all, i2) => all + i2[1], "");
        node2.raws[prop] = { raw, value };
      }
      node2[prop] = value;
    }
    rule(tokens) {
      tokens.pop();
      let node2 = new Rule$2();
      this.init(node2, tokens[0][2]);
      node2.raws.between = this.spacesAndCommentsFromEnd(tokens);
      this.raw(node2, "selector", tokens);
      this.current = node2;
    }
    spacesAndCommentsFromEnd(tokens) {
      let lastTokenType;
      let spaces = "";
      while (tokens.length) {
        lastTokenType = tokens[tokens.length - 1][0];
        if (lastTokenType !== "space" && lastTokenType !== "comment") break;
        spaces = tokens.pop()[1] + spaces;
      }
      return spaces;
    }
    // Errors
    spacesAndCommentsFromStart(tokens) {
      let next;
      let spaces = "";
      while (tokens.length) {
        next = tokens[0][0];
        if (next !== "space" && next !== "comment") break;
        spaces += tokens.shift()[1];
      }
      return spaces;
    }
    spacesFromEnd(tokens) {
      let lastTokenType;
      let spaces = "";
      while (tokens.length) {
        lastTokenType = tokens[tokens.length - 1][0];
        if (lastTokenType !== "space") break;
        spaces = tokens.pop()[1] + spaces;
      }
      return spaces;
    }
    stringFrom(tokens, from) {
      let result2 = "";
      for (let i2 = from; i2 < tokens.length; i2++) {
        result2 += tokens[i2][1];
      }
      tokens.splice(from, tokens.length - from);
      return result2;
    }
    unclosedBlock() {
      let pos = this.current.source.start;
      throw this.input.error("Unclosed block", pos.line, pos.column);
    }
    unclosedBracket(bracket) {
      throw this.input.error(
        "Unclosed bracket",
        { offset: bracket[2] },
        { offset: bracket[2] + 1 }
      );
    }
    unexpectedClose(token) {
      throw this.input.error(
        "Unexpected }",
        { offset: token[2] },
        { offset: token[2] + 1 }
      );
    }
    unknownWord(tokens) {
      throw this.input.error(
        "Unknown word",
        { offset: tokens[0][2] },
        { offset: tokens[0][2] + tokens[0][1].length }
      );
    }
    unnamedAtrule(node2, token) {
      throw this.input.error(
        "At-rule without name",
        { offset: token[2] },
        { offset: token[2] + token[1].length }
      );
    }
  };
  var parser = Parser$1;
  var Container$2 = container;
  var Parser22 = parser;
  var Input$2 = input;
  function parse$3(css, opts) {
    let input2 = new Input$2(css, opts);
    let parser2 = new Parser22(input2);
    try {
      parser2.parse();
    } catch (e2) {
      if (true) {
        if (e2.name === "CssSyntaxError" && opts && opts.from) {
          if (/\.scss$/i.test(opts.from)) {
            e2.message += "\nYou tried to parse SCSS with the standard CSS parser; try again with the postcss-scss parser";
          } else if (/\.sass/i.test(opts.from)) {
            e2.message += "\nYou tried to parse Sass with the standard CSS parser; try again with the postcss-sass parser";
          } else if (/\.less$/i.test(opts.from)) {
            e2.message += "\nYou tried to parse Less with the standard CSS parser; try again with the postcss-less parser";
          }
        }
      }
      throw e2;
    }
    return parser2.root;
  }
  var parse_1 = parse$3;
  parse$3.default = parse$3;
  Container$2.registerParse(parse$3);
  var { isClean, my } = symbols;
  var MapGenerator$1 = mapGenerator;
  var stringify$2 = stringify_1;
  var Container$1 = container;
  var Document$2 = document$1;
  var warnOnce$1 = warnOnce$2;
  var Result$2 = result;
  var parse$2 = parse_1;
  var Root$3 = root;
  var TYPE_TO_CLASS_NAME = {
    atrule: "AtRule",
    comment: "Comment",
    decl: "Declaration",
    document: "Document",
    root: "Root",
    rule: "Rule"
  };
  var PLUGIN_PROPS = {
    AtRule: true,
    AtRuleExit: true,
    Comment: true,
    CommentExit: true,
    Declaration: true,
    DeclarationExit: true,
    Document: true,
    DocumentExit: true,
    Once: true,
    OnceExit: true,
    postcssPlugin: true,
    prepare: true,
    Root: true,
    RootExit: true,
    Rule: true,
    RuleExit: true
  };
  var NOT_VISITORS = {
    Once: true,
    postcssPlugin: true,
    prepare: true
  };
  var CHILDREN = 0;
  function isPromise(obj) {
    return typeof obj === "object" && typeof obj.then === "function";
  }
  function getEvents(node2) {
    let key = false;
    let type = TYPE_TO_CLASS_NAME[node2.type];
    if (node2.type === "decl") {
      key = node2.prop.toLowerCase();
    } else if (node2.type === "atrule") {
      key = node2.name.toLowerCase();
    }
    if (key && node2.append) {
      return [
        type,
        type + "-" + key,
        CHILDREN,
        type + "Exit",
        type + "Exit-" + key
      ];
    } else if (key) {
      return [type, type + "-" + key, type + "Exit", type + "Exit-" + key];
    } else if (node2.append) {
      return [type, CHILDREN, type + "Exit"];
    } else {
      return [type, type + "Exit"];
    }
  }
  function toStack(node2) {
    let events;
    if (node2.type === "document") {
      events = ["Document", CHILDREN, "DocumentExit"];
    } else if (node2.type === "root") {
      events = ["Root", CHILDREN, "RootExit"];
    } else {
      events = getEvents(node2);
    }
    return {
      eventIndex: 0,
      events,
      iterator: 0,
      node: node2,
      visitorIndex: 0,
      visitors: []
    };
  }
  function cleanMarks(node2) {
    node2[isClean] = false;
    if (node2.nodes) node2.nodes.forEach((i2) => cleanMarks(i2));
    return node2;
  }
  var postcss$2 = {};
  var LazyResult$2 = class LazyResult2 {
    constructor(processor2, css, opts) {
      this.stringified = false;
      this.processed = false;
      let root2;
      if (typeof css === "object" && css !== null && (css.type === "root" || css.type === "document")) {
        root2 = cleanMarks(css);
      } else if (css instanceof LazyResult2 || css instanceof Result$2) {
        root2 = cleanMarks(css.root);
        if (css.map) {
          if (typeof opts.map === "undefined") opts.map = {};
          if (!opts.map.inline) opts.map.inline = false;
          opts.map.prev = css.map;
        }
      } else {
        let parser2 = parse$2;
        if (opts.syntax) parser2 = opts.syntax.parse;
        if (opts.parser) parser2 = opts.parser;
        if (parser2.parse) parser2 = parser2.parse;
        try {
          root2 = parser2(css, opts);
        } catch (error) {
          this.processed = true;
          this.error = error;
        }
        if (root2 && !root2[my]) {
          Container$1.rebuild(root2);
        }
      }
      this.result = new Result$2(processor2, root2, opts);
      this.helpers = { ...postcss$2, postcss: postcss$2, result: this.result };
      this.plugins = this.processor.plugins.map((plugin22) => {
        if (typeof plugin22 === "object" && plugin22.prepare) {
          return { ...plugin22, ...plugin22.prepare(this.result) };
        } else {
          return plugin22;
        }
      });
    }
    async() {
      if (this.error) return Promise.reject(this.error);
      if (this.processed) return Promise.resolve(this.result);
      if (!this.processing) {
        this.processing = this.runAsync();
      }
      return this.processing;
    }
    catch(onRejected) {
      return this.async().catch(onRejected);
    }
    finally(onFinally) {
      return this.async().then(onFinally, onFinally);
    }
    getAsyncError() {
      throw new Error("Use process(css).then(cb) to work with async plugins");
    }
    handleError(error, node2) {
      let plugin22 = this.result.lastPlugin;
      try {
        if (node2) node2.addToError(error);
        this.error = error;
        if (error.name === "CssSyntaxError" && !error.plugin) {
          error.plugin = plugin22.postcssPlugin;
          error.setMessage();
        } else if (plugin22.postcssVersion) {
          if (true) {
            let pluginName = plugin22.postcssPlugin;
            let pluginVer = plugin22.postcssVersion;
            let runtimeVer = this.result.processor.version;
            let a2 = pluginVer.split(".");
            let b = runtimeVer.split(".");
            if (a2[0] !== b[0] || parseInt(a2[1]) > parseInt(b[1])) {
              console.error(
                "Unknown error from PostCSS plugin. Your current PostCSS version is " + runtimeVer + ", but " + pluginName + " uses " + pluginVer + ". Perhaps this is the source of the error below."
              );
            }
          }
        }
      } catch (err) {
        if (console && console.error) console.error(err);
      }
      return error;
    }
    prepareVisitors() {
      this.listeners = {};
      let add = (plugin22, type, cb) => {
        if (!this.listeners[type]) this.listeners[type] = [];
        this.listeners[type].push([plugin22, cb]);
      };
      for (let plugin22 of this.plugins) {
        if (typeof plugin22 === "object") {
          for (let event in plugin22) {
            if (!PLUGIN_PROPS[event] && /^[A-Z]/.test(event)) {
              throw new Error(
                `Unknown event ${event} in ${plugin22.postcssPlugin}. Try to update PostCSS (${this.processor.version} now).`
              );
            }
            if (!NOT_VISITORS[event]) {
              if (typeof plugin22[event] === "object") {
                for (let filter in plugin22[event]) {
                  if (filter === "*") {
                    add(plugin22, event, plugin22[event][filter]);
                  } else {
                    add(
                      plugin22,
                      event + "-" + filter.toLowerCase(),
                      plugin22[event][filter]
                    );
                  }
                }
              } else if (typeof plugin22[event] === "function") {
                add(plugin22, event, plugin22[event]);
              }
            }
          }
        }
      }
      this.hasListener = Object.keys(this.listeners).length > 0;
    }
    async runAsync() {
      this.plugin = 0;
      for (let i2 = 0; i2 < this.plugins.length; i2++) {
        let plugin22 = this.plugins[i2];
        let promise = this.runOnRoot(plugin22);
        if (isPromise(promise)) {
          try {
            await promise;
          } catch (error) {
            throw this.handleError(error);
          }
        }
      }
      this.prepareVisitors();
      if (this.hasListener) {
        let root2 = this.result.root;
        while (!root2[isClean]) {
          root2[isClean] = true;
          let stack = [toStack(root2)];
          while (stack.length > 0) {
            let promise = this.visitTick(stack);
            if (isPromise(promise)) {
              try {
                await promise;
              } catch (e2) {
                let node2 = stack[stack.length - 1].node;
                throw this.handleError(e2, node2);
              }
            }
          }
        }
        if (this.listeners.OnceExit) {
          for (let [plugin22, visitor] of this.listeners.OnceExit) {
            this.result.lastPlugin = plugin22;
            try {
              if (root2.type === "document") {
                let roots = root2.nodes.map(
                  (subRoot) => visitor(subRoot, this.helpers)
                );
                await Promise.all(roots);
              } else {
                await visitor(root2, this.helpers);
              }
            } catch (e2) {
              throw this.handleError(e2);
            }
          }
        }
      }
      this.processed = true;
      return this.stringify();
    }
    runOnRoot(plugin22) {
      this.result.lastPlugin = plugin22;
      try {
        if (typeof plugin22 === "object" && plugin22.Once) {
          if (this.result.root.type === "document") {
            let roots = this.result.root.nodes.map(
              (root2) => plugin22.Once(root2, this.helpers)
            );
            if (isPromise(roots[0])) {
              return Promise.all(roots);
            }
            return roots;
          }
          return plugin22.Once(this.result.root, this.helpers);
        } else if (typeof plugin22 === "function") {
          return plugin22(this.result.root, this.result);
        }
      } catch (error) {
        throw this.handleError(error);
      }
    }
    stringify() {
      if (this.error) throw this.error;
      if (this.stringified) return this.result;
      this.stringified = true;
      this.sync();
      let opts = this.result.opts;
      let str = stringify$2;
      if (opts.syntax) str = opts.syntax.stringify;
      if (opts.stringifier) str = opts.stringifier;
      if (str.stringify) str = str.stringify;
      let map = new MapGenerator$1(str, this.result.root, this.result.opts);
      let data = map.generate();
      this.result.css = data[0];
      this.result.map = data[1];
      return this.result;
    }
    sync() {
      if (this.error) throw this.error;
      if (this.processed) return this.result;
      this.processed = true;
      if (this.processing) {
        throw this.getAsyncError();
      }
      for (let plugin22 of this.plugins) {
        let promise = this.runOnRoot(plugin22);
        if (isPromise(promise)) {
          throw this.getAsyncError();
        }
      }
      this.prepareVisitors();
      if (this.hasListener) {
        let root2 = this.result.root;
        while (!root2[isClean]) {
          root2[isClean] = true;
          this.walkSync(root2);
        }
        if (this.listeners.OnceExit) {
          if (root2.type === "document") {
            for (let subRoot of root2.nodes) {
              this.visitSync(this.listeners.OnceExit, subRoot);
            }
          } else {
            this.visitSync(this.listeners.OnceExit, root2);
          }
        }
      }
      return this.result;
    }
    then(onFulfilled, onRejected) {
      if (true) {
        if (!("from" in this.opts)) {
          warnOnce$1(
            "Without `from` option PostCSS could generate wrong source map and will not find Browserslist config. Set it to CSS file path or to `undefined` to prevent this warning."
          );
        }
      }
      return this.async().then(onFulfilled, onRejected);
    }
    toString() {
      return this.css;
    }
    visitSync(visitors, node2) {
      for (let [plugin22, visitor] of visitors) {
        this.result.lastPlugin = plugin22;
        let promise;
        try {
          promise = visitor(node2, this.helpers);
        } catch (e2) {
          throw this.handleError(e2, node2.proxyOf);
        }
        if (node2.type !== "root" && node2.type !== "document" && !node2.parent) {
          return true;
        }
        if (isPromise(promise)) {
          throw this.getAsyncError();
        }
      }
    }
    visitTick(stack) {
      let visit2 = stack[stack.length - 1];
      let { node: node2, visitors } = visit2;
      if (node2.type !== "root" && node2.type !== "document" && !node2.parent) {
        stack.pop();
        return;
      }
      if (visitors.length > 0 && visit2.visitorIndex < visitors.length) {
        let [plugin22, visitor] = visitors[visit2.visitorIndex];
        visit2.visitorIndex += 1;
        if (visit2.visitorIndex === visitors.length) {
          visit2.visitors = [];
          visit2.visitorIndex = 0;
        }
        this.result.lastPlugin = plugin22;
        try {
          return visitor(node2.toProxy(), this.helpers);
        } catch (e2) {
          throw this.handleError(e2, node2);
        }
      }
      if (visit2.iterator !== 0) {
        let iterator = visit2.iterator;
        let child;
        while (child = node2.nodes[node2.indexes[iterator]]) {
          node2.indexes[iterator] += 1;
          if (!child[isClean]) {
            child[isClean] = true;
            stack.push(toStack(child));
            return;
          }
        }
        visit2.iterator = 0;
        delete node2.indexes[iterator];
      }
      let events = visit2.events;
      while (visit2.eventIndex < events.length) {
        let event = events[visit2.eventIndex];
        visit2.eventIndex += 1;
        if (event === CHILDREN) {
          if (node2.nodes && node2.nodes.length) {
            node2[isClean] = true;
            visit2.iterator = node2.getIterator();
          }
          return;
        } else if (this.listeners[event]) {
          visit2.visitors = this.listeners[event];
          return;
        }
      }
      stack.pop();
    }
    walkSync(node2) {
      node2[isClean] = true;
      let events = getEvents(node2);
      for (let event of events) {
        if (event === CHILDREN) {
          if (node2.nodes) {
            node2.each((child) => {
              if (!child[isClean]) this.walkSync(child);
            });
          }
        } else {
          let visitors = this.listeners[event];
          if (visitors) {
            if (this.visitSync(visitors, node2.toProxy())) return;
          }
        }
      }
    }
    warnings() {
      return this.sync().warnings();
    }
    get content() {
      return this.stringify().content;
    }
    get css() {
      return this.stringify().css;
    }
    get map() {
      return this.stringify().map;
    }
    get messages() {
      return this.sync().messages;
    }
    get opts() {
      return this.result.opts;
    }
    get processor() {
      return this.result.processor;
    }
    get root() {
      return this.sync().root;
    }
    get [Symbol.toStringTag]() {
      return "LazyResult";
    }
  };
  LazyResult$2.registerPostcss = (dependant) => {
    postcss$2 = dependant;
  };
  var lazyResult = LazyResult$2;
  LazyResult$2.default = LazyResult$2;
  Root$3.registerLazyResult(LazyResult$2);
  Document$2.registerLazyResult(LazyResult$2);
  var MapGenerator22 = mapGenerator;
  var stringify$1 = stringify_1;
  var warnOnce22 = warnOnce$2;
  var parse$1 = parse_1;
  var Result$1 = result;
  var NoWorkResult$1 = class NoWorkResult2 {
    constructor(processor2, css, opts) {
      css = css.toString();
      this.stringified = false;
      this._processor = processor2;
      this._css = css;
      this._opts = opts;
      this._map = void 0;
      let root2;
      let str = stringify$1;
      this.result = new Result$1(this._processor, root2, this._opts);
      this.result.css = css;
      let self = this;
      Object.defineProperty(this.result, "root", {
        get() {
          return self.root;
        }
      });
      let map = new MapGenerator22(str, root2, this._opts, css);
      if (map.isMap()) {
        let [generatedCSS, generatedMap] = map.generate();
        if (generatedCSS) {
          this.result.css = generatedCSS;
        }
        if (generatedMap) {
          this.result.map = generatedMap;
        }
      } else {
        map.clearAnnotation();
        this.result.css = map.css;
      }
    }
    async() {
      if (this.error) return Promise.reject(this.error);
      return Promise.resolve(this.result);
    }
    catch(onRejected) {
      return this.async().catch(onRejected);
    }
    finally(onFinally) {
      return this.async().then(onFinally, onFinally);
    }
    sync() {
      if (this.error) throw this.error;
      return this.result;
    }
    then(onFulfilled, onRejected) {
      if (true) {
        if (!("from" in this._opts)) {
          warnOnce22(
            "Without `from` option PostCSS could generate wrong source map and will not find Browserslist config. Set it to CSS file path or to `undefined` to prevent this warning."
          );
        }
      }
      return this.async().then(onFulfilled, onRejected);
    }
    toString() {
      return this._css;
    }
    warnings() {
      return [];
    }
    get content() {
      return this.result.css;
    }
    get css() {
      return this.result.css;
    }
    get map() {
      return this.result.map;
    }
    get messages() {
      return [];
    }
    get opts() {
      return this.result.opts;
    }
    get processor() {
      return this.result.processor;
    }
    get root() {
      if (this._root) {
        return this._root;
      }
      let root2;
      let parser2 = parse$1;
      try {
        root2 = parser2(this._css, this._opts);
      } catch (error) {
        this.error = error;
      }
      if (this.error) {
        throw this.error;
      } else {
        this._root = root2;
        return root2;
      }
    }
    get [Symbol.toStringTag]() {
      return "NoWorkResult";
    }
  };
  var noWorkResult = NoWorkResult$1;
  NoWorkResult$1.default = NoWorkResult$1;
  var NoWorkResult22 = noWorkResult;
  var LazyResult$1 = lazyResult;
  var Document$1 = document$1;
  var Root$2 = root;
  var Processor$1 = class Processor2 {
    constructor(plugins = []) {
      this.version = "8.4.38";
      this.plugins = this.normalize(plugins);
    }
    normalize(plugins) {
      let normalized = [];
      for (let i2 of plugins) {
        if (i2.postcss === true) {
          i2 = i2();
        } else if (i2.postcss) {
          i2 = i2.postcss;
        }
        if (typeof i2 === "object" && Array.isArray(i2.plugins)) {
          normalized = normalized.concat(i2.plugins);
        } else if (typeof i2 === "object" && i2.postcssPlugin) {
          normalized.push(i2);
        } else if (typeof i2 === "function") {
          normalized.push(i2);
        } else if (typeof i2 === "object" && (i2.parse || i2.stringify)) {
          if (true) {
            throw new Error(
              "PostCSS syntaxes cannot be used as plugins. Instead, please use one of the syntax/parser/stringifier options as outlined in your PostCSS runner documentation."
            );
          }
        } else {
          throw new Error(i2 + " is not a PostCSS plugin");
        }
      }
      return normalized;
    }
    process(css, opts = {}) {
      if (!this.plugins.length && !opts.parser && !opts.stringifier && !opts.syntax) {
        return new NoWorkResult22(this, css, opts);
      } else {
        return new LazyResult$1(this, css, opts);
      }
    }
    use(plugin22) {
      this.plugins = this.plugins.concat(this.normalize([plugin22]));
      return this;
    }
  };
  var processor = Processor$1;
  Processor$1.default = Processor$1;
  Root$2.registerProcessor(Processor$1);
  Document$1.registerProcessor(Processor$1);
  var Declaration$1 = declaration;
  var PreviousMap22 = previousMap;
  var Comment$1 = comment;
  var AtRule$1 = atRule;
  var Input$1 = input;
  var Root$1 = root;
  var Rule$1 = rule;
  function fromJSON$1(json, inputs) {
    if (Array.isArray(json)) return json.map((n2) => fromJSON$1(n2));
    let { inputs: ownInputs, ...defaults } = json;
    if (ownInputs) {
      inputs = [];
      for (let input2 of ownInputs) {
        let inputHydrated = { ...input2, __proto__: Input$1.prototype };
        if (inputHydrated.map) {
          inputHydrated.map = {
            ...inputHydrated.map,
            __proto__: PreviousMap22.prototype
          };
        }
        inputs.push(inputHydrated);
      }
    }
    if (defaults.nodes) {
      defaults.nodes = json.nodes.map((n2) => fromJSON$1(n2, inputs));
    }
    if (defaults.source) {
      let { inputId, ...source } = defaults.source;
      defaults.source = source;
      if (inputId != null) {
        defaults.source.input = inputs[inputId];
      }
    }
    if (defaults.type === "root") {
      return new Root$1(defaults);
    } else if (defaults.type === "decl") {
      return new Declaration$1(defaults);
    } else if (defaults.type === "rule") {
      return new Rule$1(defaults);
    } else if (defaults.type === "comment") {
      return new Comment$1(defaults);
    } else if (defaults.type === "atrule") {
      return new AtRule$1(defaults);
    } else {
      throw new Error("Unknown node type: " + json.type);
    }
  }
  var fromJSON_1 = fromJSON$1;
  fromJSON$1.default = fromJSON$1;
  var CssSyntaxError22 = cssSyntaxError;
  var Declaration22 = declaration;
  var LazyResult22 = lazyResult;
  var Container22 = container;
  var Processor22 = processor;
  var stringify = stringify_1;
  var fromJSON = fromJSON_1;
  var Document222 = document$1;
  var Warning22 = warning;
  var Comment22 = comment;
  var AtRule22 = atRule;
  var Result22 = result;
  var Input22 = input;
  var parse = parse_1;
  var list = list_1;
  var Rule22 = rule;
  var Root22 = root;
  var Node22 = node;
  function postcss(...plugins) {
    if (plugins.length === 1 && Array.isArray(plugins[0])) {
      plugins = plugins[0];
    }
    return new Processor22(plugins);
  }
  postcss.plugin = function plugin2(name, initializer) {
    let warningPrinted = false;
    function creator(...args) {
      if (console && console.warn && !warningPrinted) {
        warningPrinted = true;
        console.warn(
          name + ": postcss.plugin was deprecated. Migration guide:\nhttps://evilmartians.com/chronicles/postcss-8-plugin-migration"
        );
        if (process.env.LANG && process.env.LANG.startsWith("cn")) {
          console.warn(
            name + ": \u91CC\u9762 postcss.plugin \u88AB\u5F03\u7528. \u8FC1\u79FB\u6307\u5357:\nhttps://www.w3ctech.com/topic/2226"
          );
        }
      }
      let transformer = initializer(...args);
      transformer.postcssPlugin = name;
      transformer.postcssVersion = new Processor22().version;
      return transformer;
    }
    let cache;
    Object.defineProperty(creator, "postcss", {
      get() {
        if (!cache) cache = creator();
        return cache;
      }
    });
    creator.process = function(css, processOpts, pluginOpts) {
      return postcss([creator(pluginOpts)]).process(css, processOpts);
    };
    return creator;
  };
  postcss.stringify = stringify;
  postcss.parse = parse;
  postcss.fromJSON = fromJSON;
  postcss.list = list;
  postcss.comment = (defaults) => new Comment22(defaults);
  postcss.atRule = (defaults) => new AtRule22(defaults);
  postcss.decl = (defaults) => new Declaration22(defaults);
  postcss.rule = (defaults) => new Rule22(defaults);
  postcss.root = (defaults) => new Root22(defaults);
  postcss.document = (defaults) => new Document222(defaults);
  postcss.CssSyntaxError = CssSyntaxError22;
  postcss.Declaration = Declaration22;
  postcss.Container = Container22;
  postcss.Processor = Processor22;
  postcss.Document = Document222;
  postcss.Comment = Comment22;
  postcss.Warning = Warning22;
  postcss.AtRule = AtRule22;
  postcss.Result = Result22;
  postcss.Input = Input22;
  postcss.Rule = Rule22;
  postcss.Root = Root22;
  postcss.Node = Node22;
  LazyResult22.registerPostcss(postcss);
  var postcss_1 = postcss;
  postcss.default = postcss;
  var postcss$1 = /* @__PURE__ */ getDefaultExportFromCjs(postcss_1);
  postcss$1.stringify;
  postcss$1.fromJSON;
  postcss$1.plugin;
  postcss$1.parse;
  postcss$1.list;
  postcss$1.document;
  postcss$1.comment;
  postcss$1.atRule;
  postcss$1.rule;
  postcss$1.decl;
  postcss$1.root;
  postcss$1.CssSyntaxError;
  postcss$1.Declaration;
  postcss$1.Container;
  postcss$1.Processor;
  postcss$1.Document;
  postcss$1.Comment;
  postcss$1.Warning;
  postcss$1.AtRule;
  postcss$1.Result;
  postcss$1.Input;
  postcss$1.Rule;
  postcss$1.Root;
  postcss$1.Node;
  var BaseRRNode = class _BaseRRNode {
    // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any
    constructor(..._args) {
      __publicField2(this, "parentElement", null);
      __publicField2(this, "parentNode", null);
      __publicField2(this, "ownerDocument");
      __publicField2(this, "firstChild", null);
      __publicField2(this, "lastChild", null);
      __publicField2(this, "previousSibling", null);
      __publicField2(this, "nextSibling", null);
      __publicField2(this, "ELEMENT_NODE", 1);
      __publicField2(this, "TEXT_NODE", 3);
      __publicField2(this, "nodeType");
      __publicField2(this, "nodeName");
      __publicField2(this, "RRNodeType");
    }
    get childNodes() {
      const childNodes2 = [];
      let childIterator = this.firstChild;
      while (childIterator) {
        childNodes2.push(childIterator);
        childIterator = childIterator.nextSibling;
      }
      return childNodes2;
    }
    contains(node2) {
      if (!(node2 instanceof _BaseRRNode)) return false;
      else if (node2.ownerDocument !== this.ownerDocument) return false;
      else if (node2 === this) return true;
      while (node2.parentNode) {
        if (node2.parentNode === this) return true;
        node2 = node2.parentNode;
      }
      return false;
    }
    // eslint-disable-next-line @typescript-eslint/no-unused-vars
    appendChild(_newChild) {
      throw new Error(
        `RRDomException: Failed to execute 'appendChild' on 'RRNode': This RRNode type does not support this method.`
      );
    }
    // eslint-disable-next-line @typescript-eslint/no-unused-vars
    insertBefore(_newChild, _refChild) {
      throw new Error(
        `RRDomException: Failed to execute 'insertBefore' on 'RRNode': This RRNode type does not support this method.`
      );
    }
    // eslint-disable-next-line @typescript-eslint/no-unused-vars
    removeChild(_node) {
      throw new Error(
        `RRDomException: Failed to execute 'removeChild' on 'RRNode': This RRNode type does not support this method.`
      );
    }
    toString() {
      return "RRNode";
    }
  };
  var testableAccessors = {
    Node: [
      "childNodes",
      "parentNode",
      "parentElement",
      "textContent",
      "ownerDocument"
    ],
    ShadowRoot: ["host", "styleSheets"],
    Element: ["shadowRoot", "querySelector", "querySelectorAll"],
    MutationObserver: []
  };
  var testableMethods = {
    Node: ["contains", "getRootNode"],
    ShadowRoot: ["getSelection"],
    Element: [],
    MutationObserver: ["constructor"]
  };
  var untaintedBasePrototype = {};
  var isAngularZonePresent = () => {
    return !!globalThis.Zone;
  };
  function getUntaintedPrototype(key) {
    if (untaintedBasePrototype[key])
      return untaintedBasePrototype[key];
    const defaultObj = globalThis[key];
    const defaultPrototype = defaultObj.prototype;
    const accessorNames = key in testableAccessors ? testableAccessors[key] : void 0;
    const isUntaintedAccessors = Boolean(
      accessorNames && // @ts-expect-error 2345
      accessorNames.every(
        (accessor) => {
          var _a2, _b;
          return Boolean(
            (_b = (_a2 = Object.getOwnPropertyDescriptor(defaultPrototype, accessor)) == null ? void 0 : _a2.get) == null ? void 0 : _b.toString().includes("[native code]")
          );
        }
      )
    );
    const methodNames = key in testableMethods ? testableMethods[key] : void 0;
    const isUntaintedMethods = Boolean(
      methodNames && methodNames.every(
        // @ts-expect-error 2345
        (method) => {
          var _a2;
          return typeof defaultPrototype[method] === "function" && ((_a2 = defaultPrototype[method]) == null ? void 0 : _a2.toString().includes("[native code]"));
        }
      )
    );
    if (isUntaintedAccessors && isUntaintedMethods && !isAngularZonePresent()) {
      untaintedBasePrototype[key] = defaultObj.prototype;
      return defaultObj.prototype;
    }
    try {
      const iframeEl = document.createElement("iframe");
      document.body.appendChild(iframeEl);
      const win = iframeEl.contentWindow;
      if (!win) return defaultObj.prototype;
      const untaintedObject = win[key].prototype;
      document.body.removeChild(iframeEl);
      if (!untaintedObject) return defaultPrototype;
      return untaintedBasePrototype[key] = untaintedObject;
    } catch {
      return defaultPrototype;
    }
  }
  var untaintedAccessorCache = {};
  function getUntaintedAccessor(key, instance, accessor) {
    var _a2;
    const cacheKey = `${key}.${String(accessor)}`;
    if (untaintedAccessorCache[cacheKey])
      return untaintedAccessorCache[cacheKey].call(
        instance
      );
    const untaintedPrototype = getUntaintedPrototype(key);
    const untaintedAccessor = (_a2 = Object.getOwnPropertyDescriptor(
      untaintedPrototype,
      accessor
    )) == null ? void 0 : _a2.get;
    if (!untaintedAccessor) return instance[accessor];
    untaintedAccessorCache[cacheKey] = untaintedAccessor;
    return untaintedAccessor.call(instance);
  }
  var untaintedMethodCache = {};
  function getUntaintedMethod(key, instance, method) {
    const cacheKey = `${key}.${String(method)}`;
    if (untaintedMethodCache[cacheKey])
      return untaintedMethodCache[cacheKey].bind(
        instance
      );
    const untaintedPrototype = getUntaintedPrototype(key);
    const untaintedMethod = untaintedPrototype[method];
    if (typeof untaintedMethod !== "function") return instance[method];
    untaintedMethodCache[cacheKey] = untaintedMethod;
    return untaintedMethod.bind(instance);
  }
  function ownerDocument(n2) {
    return getUntaintedAccessor("Node", n2, "ownerDocument");
  }
  function childNodes(n2) {
    return getUntaintedAccessor("Node", n2, "childNodes");
  }
  function parentNode(n2) {
    return getUntaintedAccessor("Node", n2, "parentNode");
  }
  function parentElement(n2) {
    return getUntaintedAccessor("Node", n2, "parentElement");
  }
  function textContent(n2) {
    return getUntaintedAccessor("Node", n2, "textContent");
  }
  function contains(n2, other) {
    return getUntaintedMethod("Node", n2, "contains")(other);
  }
  function getRootNode(n2) {
    return getUntaintedMethod("Node", n2, "getRootNode")();
  }
  function host(n2) {
    if (!n2 || !("host" in n2)) return null;
    return getUntaintedAccessor("ShadowRoot", n2, "host");
  }
  function styleSheets(n2) {
    return n2.styleSheets;
  }
  function shadowRoot(n2) {
    if (!n2 || !("shadowRoot" in n2)) return null;
    return getUntaintedAccessor("Element", n2, "shadowRoot");
  }
  function querySelector(n2, selectors) {
    return getUntaintedAccessor("Element", n2, "querySelector")(selectors);
  }
  function querySelectorAll(n2, selectors) {
    return getUntaintedAccessor("Element", n2, "querySelectorAll")(selectors);
  }
  function mutationObserverCtor() {
    return getUntaintedPrototype("MutationObserver").constructor;
  }
  function patch(source, name, replacement) {
    try {
      if (!(name in source)) {
        return () => {
        };
      }
      const original = source[name];
      const wrapped = replacement(original);
      if (typeof wrapped === "function") {
        wrapped.prototype = wrapped.prototype || {};
        Object.defineProperties(wrapped, {
          __rrweb_original__: {
            enumerable: false,
            value: original
          }
        });
      }
      source[name] = wrapped;
      return () => {
        source[name] = original;
      };
    } catch {
      return () => {
      };
    }
  }
  var index = {
    ownerDocument,
    childNodes,
    parentNode,
    parentElement,
    textContent,
    contains,
    getRootNode,
    host,
    styleSheets,
    shadowRoot,
    querySelector,
    querySelectorAll,
    mutationObserver: mutationObserverCtor,
    patch
  };
  function on(type, fn, target = document) {
    const options = { capture: true, passive: true };
    target.addEventListener(type, fn, options);
    return () => target.removeEventListener(type, fn, options);
  }
  var DEPARTED_MIRROR_ACCESS_WARNING = "Please stop import mirror directly. Instead of that,\r\nnow you can use replayer.getMirror() to access the mirror instance of a replayer,\r\nor you can use record.mirror to access the mirror instance during recording.";
  var _mirror = {
    map: {},
    getId() {
      console.error(DEPARTED_MIRROR_ACCESS_WARNING);
      return -1;
    },
    getNode() {
      console.error(DEPARTED_MIRROR_ACCESS_WARNING);
      return null;
    },
    removeNodeFromMap() {
      console.error(DEPARTED_MIRROR_ACCESS_WARNING);
    },
    has() {
      console.error(DEPARTED_MIRROR_ACCESS_WARNING);
      return false;
    },
    reset() {
      console.error(DEPARTED_MIRROR_ACCESS_WARNING);
    }
  };
  if (typeof window !== "undefined" && window.Proxy && window.Reflect) {
    _mirror = new Proxy(_mirror, {
      get(target, prop, receiver) {
        if (prop === "map") {
          console.error(DEPARTED_MIRROR_ACCESS_WARNING);
        }
        return Reflect.get(target, prop, receiver);
      }
    });
  }
  function throttle(func, wait, options = {}) {
    let timeout = null;
    let previous = 0;
    return function(...args) {
      const now = Date.now();
      if (!previous && options.leading === false) {
        previous = now;
      }
      const remaining = wait - (now - previous);
      const context = this;
      if (remaining <= 0 || remaining > wait) {
        if (timeout) {
          clearTimeout(timeout);
          timeout = null;
        }
        previous = now;
        func.apply(context, args);
      } else if (!timeout && options.trailing !== false) {
        timeout = setTimeout(() => {
          previous = options.leading === false ? 0 : Date.now();
          timeout = null;
          func.apply(context, args);
        }, remaining);
      }
    };
  }
  function hookSetter(target, key, d, isRevoked, win = window) {
    const original = win.Object.getOwnPropertyDescriptor(target, key);
    win.Object.defineProperty(
      target,
      key,
      isRevoked ? d : {
        set(value) {
          setTimeout(() => {
            d.set.call(this, value);
          }, 0);
          if (original && original.set) {
            original.set.call(this, value);
          }
        }
      }
    );
    return () => hookSetter(target, key, original || {}, true);
  }
  var nowTimestamp = Date.now;
  if (!/* @__PURE__ */ /[1-9][0-9]{12}/.test(Date.now().toString())) {
    nowTimestamp = () => (/* @__PURE__ */ new Date()).getTime();
  }
  function getWindowScroll(win) {
    var _a2, _b, _c, _d;
    const doc = win.document;
    return {
      left: doc.scrollingElement ? doc.scrollingElement.scrollLeft : win.pageXOffset !== void 0 ? win.pageXOffset : doc.documentElement.scrollLeft || (doc == null ? void 0 : doc.body) && ((_a2 = index.parentElement(doc.body)) == null ? void 0 : _a2.scrollLeft) || ((_b = doc == null ? void 0 : doc.body) == null ? void 0 : _b.scrollLeft) || 0,
      top: doc.scrollingElement ? doc.scrollingElement.scrollTop : win.pageYOffset !== void 0 ? win.pageYOffset : (doc == null ? void 0 : doc.documentElement.scrollTop) || (doc == null ? void 0 : doc.body) && ((_c = index.parentElement(doc.body)) == null ? void 0 : _c.scrollTop) || ((_d = doc == null ? void 0 : doc.body) == null ? void 0 : _d.scrollTop) || 0
    };
  }
  function getWindowHeight() {
    return window.innerHeight || document.documentElement && document.documentElement.clientHeight || document.body && document.body.clientHeight;
  }
  function getWindowWidth() {
    return window.innerWidth || document.documentElement && document.documentElement.clientWidth || document.body && document.body.clientWidth;
  }
  function closestElementOfNode(node2) {
    if (!node2) {
      return null;
    }
    const el = node2.nodeType === node2.ELEMENT_NODE ? node2 : index.parentElement(node2);
    return el;
  }
  function isBlocked(node2, blockClass, blockSelector, checkAncestors) {
    if (!node2) {
      return false;
    }
    const el = closestElementOfNode(node2);
    if (!el) {
      return false;
    }
    try {
      if (typeof blockClass === "string") {
        if (el.classList.contains(blockClass)) return true;
        if (checkAncestors && el.closest("." + blockClass) !== null) return true;
      } else {
        if (classMatchesRegex(el, blockClass, checkAncestors)) return true;
      }
    } catch (e2) {
    }
    if (blockSelector) {
      if (el.matches(blockSelector)) return true;
      if (checkAncestors && el.closest(blockSelector) !== null) return true;
    }
    return false;
  }
  function isSerialized(n2, mirror2) {
    return mirror2.getId(n2) !== -1;
  }
  function isIgnored(n2, mirror2, slimDOMOptions) {
    if (n2.tagName === "TITLE" && slimDOMOptions.headTitleMutations) {
      return true;
    }
    return mirror2.getId(n2) === IGNORED_NODE;
  }
  function isAncestorRemoved(target, mirror2) {
    if (isShadowRoot(target)) {
      return false;
    }
    const id = mirror2.getId(target);
    if (!mirror2.has(id)) {
      return true;
    }
    const parent = index.parentNode(target);
    if (parent && parent.nodeType === target.DOCUMENT_NODE) {
      return false;
    }
    if (!parent) {
      return true;
    }
    return isAncestorRemoved(parent, mirror2);
  }
  function legacy_isTouchEvent(event) {
    return Boolean(event.changedTouches);
  }
  function polyfill$1(win = window) {
    if ("NodeList" in win && !win.NodeList.prototype.forEach) {
      win.NodeList.prototype.forEach = Array.prototype.forEach;
    }
    if ("DOMTokenList" in win && !win.DOMTokenList.prototype.forEach) {
      win.DOMTokenList.prototype.forEach = Array.prototype.forEach;
    }
  }
  function isSerializedIframe(n2, mirror2) {
    return Boolean(n2.nodeName === "IFRAME" && mirror2.getMeta(n2));
  }
  function isSerializedStylesheet(n2, mirror2) {
    return Boolean(
      n2.nodeName === "LINK" && n2.nodeType === n2.ELEMENT_NODE && n2.getAttribute && n2.getAttribute("rel") === "stylesheet" && mirror2.getMeta(n2)
    );
  }
  function hasShadowRoot(n2) {
    if (!n2) return false;
    if (n2 instanceof BaseRRNode && "shadowRoot" in n2) {
      return Boolean(n2.shadowRoot);
    }
    return Boolean(index.shadowRoot(n2));
  }
  var StyleSheetMirror = class {
    constructor() {
      __publicField(this, "id", 1);
      __publicField(this, "styleIDMap", /* @__PURE__ */ new WeakMap());
      __publicField(this, "idStyleMap", /* @__PURE__ */ new Map());
    }
    getId(stylesheet) {
      return this.styleIDMap.get(stylesheet) ?? -1;
    }
    has(stylesheet) {
      return this.styleIDMap.has(stylesheet);
    }
    /**
     * @returns If the stylesheet is in the mirror, returns the id of the stylesheet. If not, return the new assigned id.
     */
    add(stylesheet, id) {
      if (this.has(stylesheet)) return this.getId(stylesheet);
      let newId;
      if (id === void 0) {
        newId = this.id++;
      } else newId = id;
      this.styleIDMap.set(stylesheet, newId);
      this.idStyleMap.set(newId, stylesheet);
      return newId;
    }
    getStyle(id) {
      return this.idStyleMap.get(id) || null;
    }
    reset() {
      this.styleIDMap = /* @__PURE__ */ new WeakMap();
      this.idStyleMap = /* @__PURE__ */ new Map();
      this.id = 1;
    }
    generateId() {
      return this.id++;
    }
  };
  function getShadowHost(n2) {
    var _a2;
    let shadowHost = null;
    if ("getRootNode" in n2 && ((_a2 = index.getRootNode(n2)) == null ? void 0 : _a2.nodeType) === Node.DOCUMENT_FRAGMENT_NODE && index.host(index.getRootNode(n2)))
      shadowHost = index.host(index.getRootNode(n2));
    return shadowHost;
  }
  function getRootShadowHost(n2) {
    let rootShadowHost = n2;
    let shadowHost;
    while (shadowHost = getShadowHost(rootShadowHost))
      rootShadowHost = shadowHost;
    return rootShadowHost;
  }
  function shadowHostInDom(n2) {
    const doc = index.ownerDocument(n2);
    if (!doc) return false;
    const shadowHost = getRootShadowHost(n2);
    return index.contains(doc, shadowHost);
  }
  function inDom(n2) {
    const doc = index.ownerDocument(n2);
    if (!doc) return false;
    return index.contains(doc, n2) || shadowHostInDom(n2);
  }
  var EventType = /* @__PURE__ */ ((EventType2) => {
    EventType2[EventType2["DomContentLoaded"] = 0] = "DomContentLoaded";
    EventType2[EventType2["Load"] = 1] = "Load";
    EventType2[EventType2["FullSnapshot"] = 2] = "FullSnapshot";
    EventType2[EventType2["IncrementalSnapshot"] = 3] = "IncrementalSnapshot";
    EventType2[EventType2["Meta"] = 4] = "Meta";
    EventType2[EventType2["Custom"] = 5] = "Custom";
    EventType2[EventType2["Plugin"] = 6] = "Plugin";
    return EventType2;
  })(EventType || {});
  var IncrementalSource = /* @__PURE__ */ ((IncrementalSource2) => {
    IncrementalSource2[IncrementalSource2["Mutation"] = 0] = "Mutation";
    IncrementalSource2[IncrementalSource2["MouseMove"] = 1] = "MouseMove";
    IncrementalSource2[IncrementalSource2["MouseInteraction"] = 2] = "MouseInteraction";
    IncrementalSource2[IncrementalSource2["Scroll"] = 3] = "Scroll";
    IncrementalSource2[IncrementalSource2["ViewportResize"] = 4] = "ViewportResize";
    IncrementalSource2[IncrementalSource2["Input"] = 5] = "Input";
    IncrementalSource2[IncrementalSource2["TouchMove"] = 6] = "TouchMove";
    IncrementalSource2[IncrementalSource2["MediaInteraction"] = 7] = "MediaInteraction";
    IncrementalSource2[IncrementalSource2["StyleSheetRule"] = 8] = "StyleSheetRule";
    IncrementalSource2[IncrementalSource2["CanvasMutation"] = 9] = "CanvasMutation";
    IncrementalSource2[IncrementalSource2["Font"] = 10] = "Font";
    IncrementalSource2[IncrementalSource2["Log"] = 11] = "Log";
    IncrementalSource2[IncrementalSource2["Drag"] = 12] = "Drag";
    IncrementalSource2[IncrementalSource2["StyleDeclaration"] = 13] = "StyleDeclaration";
    IncrementalSource2[IncrementalSource2["Selection"] = 14] = "Selection";
    IncrementalSource2[IncrementalSource2["AdoptedStyleSheet"] = 15] = "AdoptedStyleSheet";
    IncrementalSource2[IncrementalSource2["CustomElement"] = 16] = "CustomElement";
    return IncrementalSource2;
  })(IncrementalSource || {});
  var MouseInteractions = /* @__PURE__ */ ((MouseInteractions2) => {
    MouseInteractions2[MouseInteractions2["MouseUp"] = 0] = "MouseUp";
    MouseInteractions2[MouseInteractions2["MouseDown"] = 1] = "MouseDown";
    MouseInteractions2[MouseInteractions2["Click"] = 2] = "Click";
    MouseInteractions2[MouseInteractions2["ContextMenu"] = 3] = "ContextMenu";
    MouseInteractions2[MouseInteractions2["DblClick"] = 4] = "DblClick";
    MouseInteractions2[MouseInteractions2["Focus"] = 5] = "Focus";
    MouseInteractions2[MouseInteractions2["Blur"] = 6] = "Blur";
    MouseInteractions2[MouseInteractions2["TouchStart"] = 7] = "TouchStart";
    MouseInteractions2[MouseInteractions2["TouchMove_Departed"] = 8] = "TouchMove_Departed";
    MouseInteractions2[MouseInteractions2["TouchEnd"] = 9] = "TouchEnd";
    MouseInteractions2[MouseInteractions2["TouchCancel"] = 10] = "TouchCancel";
    return MouseInteractions2;
  })(MouseInteractions || {});
  var PointerTypes = /* @__PURE__ */ ((PointerTypes2) => {
    PointerTypes2[PointerTypes2["Mouse"] = 0] = "Mouse";
    PointerTypes2[PointerTypes2["Pen"] = 1] = "Pen";
    PointerTypes2[PointerTypes2["Touch"] = 2] = "Touch";
    return PointerTypes2;
  })(PointerTypes || {});
  var CanvasContext = /* @__PURE__ */ ((CanvasContext2) => {
    CanvasContext2[CanvasContext2["2D"] = 0] = "2D";
    CanvasContext2[CanvasContext2["WebGL"] = 1] = "WebGL";
    CanvasContext2[CanvasContext2["WebGL2"] = 2] = "WebGL2";
    return CanvasContext2;
  })(CanvasContext || {});
  var MediaInteractions = /* @__PURE__ */ ((MediaInteractions2) => {
    MediaInteractions2[MediaInteractions2["Play"] = 0] = "Play";
    MediaInteractions2[MediaInteractions2["Pause"] = 1] = "Pause";
    MediaInteractions2[MediaInteractions2["Seeked"] = 2] = "Seeked";
    MediaInteractions2[MediaInteractions2["VolumeChange"] = 3] = "VolumeChange";
    MediaInteractions2[MediaInteractions2["RateChange"] = 4] = "RateChange";
    return MediaInteractions2;
  })(MediaInteractions || {});
  var NodeType = /* @__PURE__ */ ((NodeType22) => {
    NodeType22[NodeType22["Document"] = 0] = "Document";
    NodeType22[NodeType22["DocumentType"] = 1] = "DocumentType";
    NodeType22[NodeType22["Element"] = 2] = "Element";
    NodeType22[NodeType22["Text"] = 3] = "Text";
    NodeType22[NodeType22["CDATA"] = 4] = "CDATA";
    NodeType22[NodeType22["Comment"] = 5] = "Comment";
    return NodeType22;
  })(NodeType || {});
  function isNodeInLinkedList(n2) {
    return "__ln" in n2;
  }
  var DoubleLinkedList = class {
    constructor() {
      __publicField(this, "length", 0);
      __publicField(this, "head", null);
      __publicField(this, "tail", null);
    }
    get(position) {
      if (position >= this.length) {
        throw new Error("Position outside of list range");
      }
      let current = this.head;
      for (let index2 = 0; index2 < position; index2++) {
        current = (current == null ? void 0 : current.next) || null;
      }
      return current;
    }
    addNode(n2) {
      const node2 = {
        value: n2,
        previous: null,
        next: null
      };
      n2.__ln = node2;
      if (n2.previousSibling && isNodeInLinkedList(n2.previousSibling)) {
        const current = n2.previousSibling.__ln.next;
        node2.next = current;
        node2.previous = n2.previousSibling.__ln;
        n2.previousSibling.__ln.next = node2;
        if (current) {
          current.previous = node2;
        }
      } else if (n2.nextSibling && isNodeInLinkedList(n2.nextSibling) && n2.nextSibling.__ln.previous) {
        const current = n2.nextSibling.__ln.previous;
        node2.previous = current;
        node2.next = n2.nextSibling.__ln;
        n2.nextSibling.__ln.previous = node2;
        if (current) {
          current.next = node2;
        }
      } else {
        if (this.head) {
          this.head.previous = node2;
        }
        node2.next = this.head;
        this.head = node2;
      }
      if (node2.next === null) {
        this.tail = node2;
      }
      this.length++;
    }
    removeNode(n2) {
      const current = n2.__ln;
      if (!this.head) {
        return;
      }
      if (!current.previous) {
        this.head = current.next;
        if (this.head) {
          this.head.previous = null;
        } else {
          this.tail = null;
        }
      } else {
        current.previous.next = current.next;
        if (current.next) {
          current.next.previous = current.previous;
        } else {
          this.tail = current.previous;
        }
      }
      if (n2.__ln) {
        delete n2.__ln;
      }
      this.length--;
    }
  };
  var moveKey = (id, parentId) => `${id}@${parentId}`;
  var MutationBuffer = class {
    constructor() {
      __publicField(this, "frozen", false);
      __publicField(this, "locked", false);
      __publicField(this, "texts", []);
      __publicField(this, "attributes", []);
      __publicField(this, "attributeMap", /* @__PURE__ */ new WeakMap());
      __publicField(this, "removes", []);
      __publicField(this, "mapRemoves", []);
      __publicField(this, "movedMap", {});
      __publicField(this, "addedSet", /* @__PURE__ */ new Set());
      __publicField(this, "movedSet", /* @__PURE__ */ new Set());
      __publicField(this, "droppedSet", /* @__PURE__ */ new Set());
      __publicField(this, "removesSubTreeCache", /* @__PURE__ */ new Set());
      __publicField(this, "mutationCb");
      __publicField(this, "blockClass");
      __publicField(this, "blockSelector");
      __publicField(this, "maskTextClass");
      __publicField(this, "maskTextSelector");
      __publicField(this, "inlineStylesheet");
      __publicField(this, "maskInputOptions");
      __publicField(this, "maskTextFn");
      __publicField(this, "maskInputFn");
      __publicField(this, "keepIframeSrcFn");
      __publicField(this, "recordCanvas");
      __publicField(this, "inlineImages");
      __publicField(this, "slimDOMOptions");
      __publicField(this, "dataURLOptions");
      __publicField(this, "doc");
      __publicField(this, "mirror");
      __publicField(this, "iframeManager");
      __publicField(this, "stylesheetManager");
      __publicField(this, "shadowDomManager");
      __publicField(this, "canvasManager");
      __publicField(this, "processedNodeManager");
      __publicField(this, "unattachedDoc");
      __publicField(this, "processMutations", (mutations) => {
        mutations.forEach(this.processMutation);
        this.emit();
      });
      __publicField(this, "emit", () => {
        if (this.frozen || this.locked) {
          return;
        }
        const adds = [];
        const addedIds = /* @__PURE__ */ new Set();
        const addList = new DoubleLinkedList();
        const getNextId = (n2) => {
          let ns = n2;
          let nextId = IGNORED_NODE;
          while (nextId === IGNORED_NODE) {
            ns = ns && ns.nextSibling;
            nextId = ns && this.mirror.getId(ns);
          }
          return nextId;
        };
        const pushAdd = (n2) => {
          const parent = index.parentNode(n2);
          if (!parent || !inDom(n2)) {
            return;
          }
          let cssCaptured = false;
          if (n2.nodeType === Node.TEXT_NODE) {
            const parentTag = parent.tagName;
            if (parentTag === "TEXTAREA") {
              return;
            } else if (parentTag === "STYLE" && this.addedSet.has(parent)) {
              cssCaptured = true;
            }
          }
          const parentId = isShadowRoot(parent) ? this.mirror.getId(getShadowHost(n2)) : this.mirror.getId(parent);
          const nextId = getNextId(n2);
          if (parentId === -1 || nextId === -1) {
            return addList.addNode(n2);
          }
          const sn = serializeNodeWithId(n2, {
            doc: this.doc,
            mirror: this.mirror,
            blockClass: this.blockClass,
            blockSelector: this.blockSelector,
            maskTextClass: this.maskTextClass,
            maskTextSelector: this.maskTextSelector,
            skipChild: true,
            newlyAddedElement: true,
            inlineStylesheet: this.inlineStylesheet,
            maskInputOptions: this.maskInputOptions,
            maskTextFn: this.maskTextFn,
            maskInputFn: this.maskInputFn,
            slimDOMOptions: this.slimDOMOptions,
            dataURLOptions: this.dataURLOptions,
            recordCanvas: this.recordCanvas,
            inlineImages: this.inlineImages,
            onSerialize: (currentN) => {
              if (isSerializedIframe(currentN, this.mirror)) {
                this.iframeManager.addIframe(currentN);
              }
              if (isSerializedStylesheet(currentN, this.mirror)) {
                this.stylesheetManager.trackLinkElement(
                  currentN
                );
              }
              if (hasShadowRoot(n2)) {
                this.shadowDomManager.addShadowRoot(index.shadowRoot(n2), this.doc);
              }
            },
            onIframeLoad: (iframe, childSn) => {
              this.iframeManager.attachIframe(iframe, childSn);
              this.shadowDomManager.observeAttachShadow(iframe);
            },
            onStylesheetLoad: (link, childSn) => {
              this.stylesheetManager.attachLinkElement(link, childSn);
            },
            cssCaptured
          });
          if (sn) {
            adds.push({
              parentId,
              nextId,
              node: sn
            });
            addedIds.add(sn.id);
          }
        };
        while (this.mapRemoves.length) {
          this.mirror.removeNodeFromMap(this.mapRemoves.shift());
        }
        for (const n2 of this.movedSet) {
          if (isParentRemoved(this.removesSubTreeCache, n2, this.mirror) && !this.movedSet.has(index.parentNode(n2))) {
            continue;
          }
          pushAdd(n2);
        }
        for (const n2 of this.addedSet) {
          if (!isAncestorInSet(this.droppedSet, n2) && !isParentRemoved(this.removesSubTreeCache, n2, this.mirror)) {
            pushAdd(n2);
          } else if (isAncestorInSet(this.movedSet, n2)) {
            pushAdd(n2);
          } else {
            this.droppedSet.add(n2);
          }
        }
        let candidate = null;
        while (addList.length) {
          let node2 = null;
          if (candidate) {
            const parentId = this.mirror.getId(index.parentNode(candidate.value));
            const nextId = getNextId(candidate.value);
            if (parentId !== -1 && nextId !== -1) {
              node2 = candidate;
            }
          }
          if (!node2) {
            let tailNode = addList.tail;
            while (tailNode) {
              const _node = tailNode;
              tailNode = tailNode.previous;
              if (_node) {
                const parentId = this.mirror.getId(index.parentNode(_node.value));
                const nextId = getNextId(_node.value);
                if (nextId === -1) continue;
                else if (parentId !== -1) {
                  node2 = _node;
                  break;
                } else {
                  const unhandledNode = _node.value;
                  const parent = index.parentNode(unhandledNode);
                  if (parent && parent.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
                    const shadowHost = index.host(parent);
                    const parentId2 = this.mirror.getId(shadowHost);
                    if (parentId2 !== -1) {
                      node2 = _node;
                      break;
                    }
                  }
                }
              }
            }
          }
          if (!node2) {
            while (addList.head) {
              addList.removeNode(addList.head.value);
            }
            break;
          }
          candidate = node2.previous;
          addList.removeNode(node2.value);
          pushAdd(node2.value);
        }
        const payload = {
          texts: this.texts.map((text) => {
            const n2 = text.node;
            const parent = index.parentNode(n2);
            if (parent && parent.tagName === "TEXTAREA") {
              this.genTextAreaValueMutation(parent);
            }
            return {
              id: this.mirror.getId(n2),
              value: text.value
            };
          }).filter((text) => !addedIds.has(text.id)).filter((text) => this.mirror.has(text.id)),
          attributes: this.attributes.map((attribute) => {
            const { attributes } = attribute;
            if (typeof attributes.style === "string") {
              const diffAsStr = JSON.stringify(attribute.styleDiff);
              const unchangedAsStr = JSON.stringify(attribute._unchangedStyles);
              if (diffAsStr.length < attributes.style.length) {
                if ((diffAsStr + unchangedAsStr).split("var(").length === attributes.style.split("var(").length) {
                  attributes.style = attribute.styleDiff;
                }
              }
            }
            return {
              id: this.mirror.getId(attribute.node),
              attributes
            };
          }).filter((attribute) => !addedIds.has(attribute.id)).filter((attribute) => this.mirror.has(attribute.id)),
          removes: this.removes,
          adds
        };
        if (!payload.texts.length && !payload.attributes.length && !payload.removes.length && !payload.adds.length) {
          return;
        }
        this.texts = [];
        this.attributes = [];
        this.attributeMap = /* @__PURE__ */ new WeakMap();
        this.removes = [];
        this.addedSet = /* @__PURE__ */ new Set();
        this.movedSet = /* @__PURE__ */ new Set();
        this.droppedSet = /* @__PURE__ */ new Set();
        this.removesSubTreeCache = /* @__PURE__ */ new Set();
        this.movedMap = {};
        this.mutationCb(payload);
      });
      __publicField(this, "genTextAreaValueMutation", (textarea) => {
        let item = this.attributeMap.get(textarea);
        if (!item) {
          item = {
            node: textarea,
            attributes: {},
            styleDiff: {},
            _unchangedStyles: {}
          };
          this.attributes.push(item);
          this.attributeMap.set(textarea, item);
        }
        const value = Array.from(
          index.childNodes(textarea),
          (cn) => index.textContent(cn) || ""
        ).join("");
        item.attributes.value = maskInputValue({
          element: textarea,
          maskInputOptions: this.maskInputOptions,
          tagName: textarea.tagName,
          type: getInputType(textarea),
          value,
          maskInputFn: this.maskInputFn
        });
      });
      __publicField(this, "processMutation", (m) => {
        if (isIgnored(m.target, this.mirror, this.slimDOMOptions)) {
          return;
        }
        switch (m.type) {
          case "characterData": {
            const value = index.textContent(m.target);
            if (!isBlocked(m.target, this.blockClass, this.blockSelector, false) && value !== m.oldValue) {
              this.texts.push({
                value: needMaskingText(
                  m.target,
                  this.maskTextClass,
                  this.maskTextSelector,
                  true
                  // checkAncestors
                ) && value ? this.maskTextFn ? this.maskTextFn(value, closestElementOfNode(m.target)) : value.replace(/[\S]/g, "*") : value,
                node: m.target
              });
            }
            break;
          }
          case "attributes": {
            const target = m.target;
            let attributeName = m.attributeName;
            let value = m.target.getAttribute(attributeName);
            if (attributeName === "value") {
              const type = getInputType(target);
              value = maskInputValue({
                element: target,
                maskInputOptions: this.maskInputOptions,
                tagName: target.tagName,
                type,
                value,
                maskInputFn: this.maskInputFn
              });
            }
            if (isBlocked(m.target, this.blockClass, this.blockSelector, false) || value === m.oldValue) {
              return;
            }
            let item = this.attributeMap.get(m.target);
            if (target.tagName === "IFRAME" && attributeName === "src" && !this.keepIframeSrcFn(value)) {
              if (!target.contentDocument) {
                attributeName = "rr_src";
              } else {
                return;
              }
            }
            if (!item) {
              item = {
                node: m.target,
                attributes: {},
                styleDiff: {},
                _unchangedStyles: {}
              };
              this.attributes.push(item);
              this.attributeMap.set(m.target, item);
            }
            if (attributeName === "type" && target.tagName === "INPUT" && (m.oldValue || "").toLowerCase() === "password") {
              target.setAttribute("data-rr-is-password", "true");
            }
            if (!ignoreAttribute(target.tagName, attributeName)) {
              item.attributes[attributeName] = transformAttribute(
                this.doc,
                toLowerCase(target.tagName),
                toLowerCase(attributeName),
                value
              );
              if (attributeName === "style") {
                if (!this.unattachedDoc) {
                  try {
                    this.unattachedDoc = document.implementation.createHTMLDocument();
                  } catch (e2) {
                    this.unattachedDoc = this.doc;
                  }
                }
                const old = this.unattachedDoc.createElement("span");
                if (m.oldValue) {
                  old.setAttribute("style", m.oldValue);
                }
                for (const pname of Array.from(target.style)) {
                  const newValue = target.style.getPropertyValue(pname);
                  const newPriority = target.style.getPropertyPriority(pname);
                  if (newValue !== old.style.getPropertyValue(pname) || newPriority !== old.style.getPropertyPriority(pname)) {
                    if (newPriority === "") {
                      item.styleDiff[pname] = newValue;
                    } else {
                      item.styleDiff[pname] = [newValue, newPriority];
                    }
                  } else {
                    item._unchangedStyles[pname] = [newValue, newPriority];
                  }
                }
                for (const pname of Array.from(old.style)) {
                  if (target.style.getPropertyValue(pname) === "") {
                    item.styleDiff[pname] = false;
                  }
                }
              } else if (attributeName === "open" && target.tagName === "DIALOG") {
                if (target.matches("dialog:modal")) {
                  item.attributes["rr_open_mode"] = "modal";
                } else {
                  item.attributes["rr_open_mode"] = "non-modal";
                }
              }
            }
            break;
          }
          case "childList": {
            if (isBlocked(m.target, this.blockClass, this.blockSelector, true))
              return;
            if (m.target.tagName === "TEXTAREA") {
              this.genTextAreaValueMutation(m.target);
              return;
            }
            m.addedNodes.forEach((n2) => this.genAdds(n2, m.target));
            m.removedNodes.forEach((n2) => {
              const nodeId = this.mirror.getId(n2);
              const parentId = isShadowRoot(m.target) ? this.mirror.getId(index.host(m.target)) : this.mirror.getId(m.target);
              if (isBlocked(m.target, this.blockClass, this.blockSelector, false) || isIgnored(n2, this.mirror, this.slimDOMOptions) || !isSerialized(n2, this.mirror)) {
                return;
              }
              if (this.addedSet.has(n2)) {
                deepDelete(this.addedSet, n2);
                this.droppedSet.add(n2);
              } else if (this.addedSet.has(m.target) && nodeId === -1) ;
              else if (isAncestorRemoved(m.target, this.mirror)) ;
              else if (this.movedSet.has(n2) && this.movedMap[moveKey(nodeId, parentId)]) {
                deepDelete(this.movedSet, n2);
              } else {
                this.removes.push({
                  parentId,
                  id: nodeId,
                  isShadow: isShadowRoot(m.target) && isNativeShadowDom(m.target) ? true : void 0
                });
                processRemoves(n2, this.removesSubTreeCache);
              }
              this.mapRemoves.push(n2);
            });
            break;
          }
        }
      });
      __publicField(this, "genAdds", (n2, target) => {
        if (this.processedNodeManager.inOtherBuffer(n2, this)) return;
        if (this.addedSet.has(n2) || this.movedSet.has(n2)) return;
        if (this.mirror.hasNode(n2)) {
          if (isIgnored(n2, this.mirror, this.slimDOMOptions)) {
            return;
          }
          this.movedSet.add(n2);
          let targetId = null;
          if (target && this.mirror.hasNode(target)) {
            targetId = this.mirror.getId(target);
          }
          if (targetId && targetId !== -1) {
            this.movedMap[moveKey(this.mirror.getId(n2), targetId)] = true;
          }
        } else {
          this.addedSet.add(n2);
          this.droppedSet.delete(n2);
        }
        if (!isBlocked(n2, this.blockClass, this.blockSelector, false)) {
          index.childNodes(n2).forEach((childN) => this.genAdds(childN));
          if (hasShadowRoot(n2)) {
            index.childNodes(index.shadowRoot(n2)).forEach((childN) => {
              this.processedNodeManager.add(childN, this);
              this.genAdds(childN, n2);
            });
          }
        }
      });
    }
    init(options) {
      [
        "mutationCb",
        "blockClass",
        "blockSelector",
        "maskTextClass",
        "maskTextSelector",
        "inlineStylesheet",
        "maskInputOptions",
        "maskTextFn",
        "maskInputFn",
        "keepIframeSrcFn",
        "recordCanvas",
        "inlineImages",
        "slimDOMOptions",
        "dataURLOptions",
        "doc",
        "mirror",
        "iframeManager",
        "stylesheetManager",
        "shadowDomManager",
        "canvasManager",
        "processedNodeManager"
      ].forEach((key) => {
        this[key] = options[key];
      });
    }
    freeze() {
      this.frozen = true;
      this.canvasManager.freeze();
    }
    unfreeze() {
      this.frozen = false;
      this.canvasManager.unfreeze();
      this.emit();
    }
    isFrozen() {
      return this.frozen;
    }
    lock() {
      this.locked = true;
      this.canvasManager.lock();
    }
    unlock() {
      this.locked = false;
      this.canvasManager.unlock();
      this.emit();
    }
    reset() {
      this.shadowDomManager.reset();
      this.canvasManager.reset();
    }
  };
  function deepDelete(addsSet, n2) {
    addsSet.delete(n2);
    index.childNodes(n2).forEach((childN) => deepDelete(addsSet, childN));
  }
  function processRemoves(n2, cache) {
    const queue = [n2];
    while (queue.length) {
      const next = queue.pop();
      if (cache.has(next)) continue;
      cache.add(next);
      index.childNodes(next).forEach((n22) => queue.push(n22));
    }
    return;
  }
  function isParentRemoved(removes, n2, mirror2) {
    if (removes.size === 0) return false;
    return _isParentRemoved(removes, n2);
  }
  function _isParentRemoved(removes, n2, _mirror2) {
    const node2 = index.parentNode(n2);
    if (!node2) return false;
    return removes.has(node2);
  }
  function isAncestorInSet(set, n2) {
    if (set.size === 0) return false;
    return _isAncestorInSet(set, n2);
  }
  function _isAncestorInSet(set, n2) {
    const parent = index.parentNode(n2);
    if (!parent) {
      return false;
    }
    if (set.has(parent)) {
      return true;
    }
    return _isAncestorInSet(set, parent);
  }
  var errorHandler;
  function registerErrorHandler(handler) {
    errorHandler = handler;
  }
  function unregisterErrorHandler() {
    errorHandler = void 0;
  }
  var callbackWrapper = (cb) => {
    if (!errorHandler) {
      return cb;
    }
    const rrwebWrapped = (...rest) => {
      try {
        return cb(...rest);
      } catch (error) {
        if (errorHandler && errorHandler(error) === true) {
          return;
        }
        throw error;
      }
    };
    return rrwebWrapped;
  };
  var mutationBuffers = [];
  function getEventTarget(event) {
    try {
      if ("composedPath" in event) {
        const path = event.composedPath();
        if (path.length) {
          return path[0];
        }
      } else if ("path" in event && event.path.length) {
        return event.path[0];
      }
    } catch {
    }
    return event && event.target;
  }
  function initMutationObserver(options, rootEl) {
    const mutationBuffer = new MutationBuffer();
    mutationBuffers.push(mutationBuffer);
    mutationBuffer.init(options);
    const observer = new (mutationObserverCtor())(
      callbackWrapper(mutationBuffer.processMutations.bind(mutationBuffer))
    );
    observer.observe(rootEl, {
      attributes: true,
      attributeOldValue: true,
      characterData: true,
      characterDataOldValue: true,
      childList: true,
      subtree: true
    });
    return observer;
  }
  function initMoveObserver({
    mousemoveCb,
    sampling,
    doc,
    mirror: mirror2
  }) {
    if (sampling.mousemove === false) {
      return () => {
      };
    }
    const threshold = typeof sampling.mousemove === "number" ? sampling.mousemove : 50;
    const callbackThreshold = typeof sampling.mousemoveCallback === "number" ? sampling.mousemoveCallback : 500;
    let positions = [];
    let timeBaseline;
    const wrappedCb = throttle(
      callbackWrapper(
        (source) => {
          const totalOffset = Date.now() - timeBaseline;
          mousemoveCb(
            positions.map((p) => {
              p.timeOffset -= totalOffset;
              return p;
            }),
            source
          );
          positions = [];
          timeBaseline = null;
        }
      ),
      callbackThreshold
    );
    const updatePosition = callbackWrapper(
      throttle(
        callbackWrapper((evt) => {
          const target = getEventTarget(evt);
          const { clientX, clientY } = legacy_isTouchEvent(evt) ? evt.changedTouches[0] : evt;
          if (!timeBaseline) {
            timeBaseline = nowTimestamp();
          }
          positions.push({
            x: clientX,
            y: clientY,
            id: mirror2.getId(target),
            timeOffset: nowTimestamp() - timeBaseline
          });
          wrappedCb(
            typeof DragEvent !== "undefined" && evt instanceof DragEvent ? IncrementalSource.Drag : evt instanceof MouseEvent ? IncrementalSource.MouseMove : IncrementalSource.TouchMove
          );
        }),
        threshold,
        {
          trailing: false
        }
      )
    );
    const handlers = [
      on("mousemove", updatePosition, doc),
      on("touchmove", updatePosition, doc),
      on("drag", updatePosition, doc)
    ];
    return callbackWrapper(() => {
      handlers.forEach((h) => h());
    });
  }
  function initMouseInteractionObserver({
    mouseInteractionCb,
    doc,
    mirror: mirror2,
    blockClass,
    blockSelector,
    sampling
  }) {
    if (sampling.mouseInteraction === false) {
      return () => {
      };
    }
    const disableMap = sampling.mouseInteraction === true || sampling.mouseInteraction === void 0 ? {} : sampling.mouseInteraction;
    const handlers = [];
    let currentPointerType = null;
    const getHandler = (eventKey) => {
      return (event) => {
        const target = getEventTarget(event);
        if (isBlocked(target, blockClass, blockSelector, true)) {
          return;
        }
        let pointerType = null;
        let thisEventKey = eventKey;
        if ("pointerType" in event) {
          switch (event.pointerType) {
            case "mouse":
              pointerType = PointerTypes.Mouse;
              break;
            case "touch":
              pointerType = PointerTypes.Touch;
              break;
            case "pen":
              pointerType = PointerTypes.Pen;
              break;
          }
          if (pointerType === PointerTypes.Touch) {
            if (MouseInteractions[eventKey] === MouseInteractions.MouseDown) {
              thisEventKey = "TouchStart";
            } else if (MouseInteractions[eventKey] === MouseInteractions.MouseUp) {
              thisEventKey = "TouchEnd";
            }
          } else if (pointerType === PointerTypes.Pen) ;
        } else if (legacy_isTouchEvent(event)) {
          pointerType = PointerTypes.Touch;
        }
        if (pointerType !== null) {
          currentPointerType = pointerType;
          if (thisEventKey.startsWith("Touch") && pointerType === PointerTypes.Touch || thisEventKey.startsWith("Mouse") && pointerType === PointerTypes.Mouse) {
            pointerType = null;
          }
        } else if (MouseInteractions[eventKey] === MouseInteractions.Click) {
          pointerType = currentPointerType;
          currentPointerType = null;
        }
        const e2 = legacy_isTouchEvent(event) ? event.changedTouches[0] : event;
        if (!e2) {
          return;
        }
        const id = mirror2.getId(target);
        const { clientX, clientY } = e2;
        callbackWrapper(mouseInteractionCb)({
          type: MouseInteractions[thisEventKey],
          id,
          x: clientX,
          y: clientY,
          ...pointerType !== null && { pointerType }
        });
      };
    };
    Object.keys(MouseInteractions).filter(
      (key) => Number.isNaN(Number(key)) && !key.endsWith("_Departed") && disableMap[key] !== false
    ).forEach((eventKey) => {
      let eventName = toLowerCase(eventKey);
      const handler = getHandler(eventKey);
      if (window.PointerEvent) {
        switch (MouseInteractions[eventKey]) {
          case MouseInteractions.MouseDown:
          case MouseInteractions.MouseUp:
            eventName = eventName.replace(
              "mouse",
              "pointer"
            );
            break;
          case MouseInteractions.TouchStart:
          case MouseInteractions.TouchEnd:
            return;
        }
      }
      handlers.push(on(eventName, handler, doc));
    });
    return callbackWrapper(() => {
      handlers.forEach((h) => h());
    });
  }
  function initScrollObserver({
    scrollCb,
    doc,
    mirror: mirror2,
    blockClass,
    blockSelector,
    sampling
  }) {
    const updatePosition = callbackWrapper(
      throttle(
        callbackWrapper((evt) => {
          const target = getEventTarget(evt);
          if (!target || isBlocked(target, blockClass, blockSelector, true)) {
            return;
          }
          const id = mirror2.getId(target);
          if (target === doc && doc.defaultView) {
            const scrollLeftTop = getWindowScroll(doc.defaultView);
            scrollCb({
              id,
              x: scrollLeftTop.left,
              y: scrollLeftTop.top
            });
          } else {
            scrollCb({
              id,
              x: target.scrollLeft,
              y: target.scrollTop
            });
          }
        }),
        sampling.scroll || 100
      )
    );
    return on("scroll", updatePosition, doc);
  }
  function initViewportResizeObserver({ viewportResizeCb }, { win }) {
    let lastH = -1;
    let lastW = -1;
    const updateDimension = callbackWrapper(
      throttle(
        callbackWrapper(() => {
          const height = getWindowHeight();
          const width = getWindowWidth();
          if (lastH !== height || lastW !== width) {
            viewportResizeCb({
              width: Number(width),
              height: Number(height)
            });
            lastH = height;
            lastW = width;
          }
        }),
        200
      )
    );
    return on("resize", updateDimension, win);
  }
  var INPUT_TAGS = ["INPUT", "TEXTAREA", "SELECT"];
  var lastInputValueMap = /* @__PURE__ */ new WeakMap();
  function initInputObserver({
    inputCb,
    doc,
    mirror: mirror2,
    blockClass,
    blockSelector,
    ignoreClass,
    ignoreSelector,
    maskInputOptions,
    maskInputFn,
    sampling,
    userTriggeredOnInput
  }) {
    function eventHandler(event) {
      let target = getEventTarget(event);
      const userTriggered = event.isTrusted;
      const tagName = target && target.tagName;
      if (target && tagName === "OPTION") {
        target = index.parentElement(target);
      }
      if (!target || !tagName || INPUT_TAGS.indexOf(tagName) < 0 || isBlocked(target, blockClass, blockSelector, true)) {
        return;
      }
      if (target.classList.contains(ignoreClass) || ignoreSelector && target.matches(ignoreSelector)) {
        return;
      }
      let text = target.value;
      let isChecked = false;
      const type = getInputType(target) || "";
      if (type === "radio" || type === "checkbox") {
        isChecked = target.checked;
      } else if (maskInputOptions[tagName.toLowerCase()] || maskInputOptions[type]) {
        text = maskInputValue({
          element: target,
          maskInputOptions,
          tagName,
          type,
          value: text,
          maskInputFn
        });
      }
      cbWithDedup(
        target,
        userTriggeredOnInput ? { text, isChecked, userTriggered } : { text, isChecked }
      );
      const name = target.name;
      if (type === "radio" && name && isChecked) {
        doc.querySelectorAll(`input[type="radio"][name="${name}"]`).forEach((el) => {
          if (el !== target) {
            const text2 = el.value;
            cbWithDedup(
              el,
              userTriggeredOnInput ? { text: text2, isChecked: !isChecked, userTriggered: false } : { text: text2, isChecked: !isChecked }
            );
          }
        });
      }
    }
    function cbWithDedup(target, v2) {
      const lastInputValue = lastInputValueMap.get(target);
      if (!lastInputValue || lastInputValue.text !== v2.text || lastInputValue.isChecked !== v2.isChecked) {
        lastInputValueMap.set(target, v2);
        const id = mirror2.getId(target);
        callbackWrapper(inputCb)({
          ...v2,
          id
        });
      }
    }
    const events = sampling.input === "last" ? ["change"] : ["input", "change"];
    const handlers = events.map(
      (eventName) => on(eventName, callbackWrapper(eventHandler), doc)
    );
    const currentWindow = doc.defaultView;
    if (!currentWindow) {
      return () => {
        handlers.forEach((h) => h());
      };
    }
    const propertyDescriptor = currentWindow.Object.getOwnPropertyDescriptor(
      currentWindow.HTMLInputElement.prototype,
      "value"
    );
    const hookProperties = [
      [currentWindow.HTMLInputElement.prototype, "value"],
      [currentWindow.HTMLInputElement.prototype, "checked"],
      [currentWindow.HTMLSelectElement.prototype, "value"],
      [currentWindow.HTMLTextAreaElement.prototype, "value"],
      // Some UI library use selectedIndex to set select value
      [currentWindow.HTMLSelectElement.prototype, "selectedIndex"],
      [currentWindow.HTMLOptionElement.prototype, "selected"]
    ];
    if (propertyDescriptor && propertyDescriptor.set) {
      handlers.push(
        ...hookProperties.map(
          (p) => hookSetter(
            p[0],
            p[1],
            {
              set() {
                callbackWrapper(eventHandler)({
                  target: this,
                  isTrusted: false
                  // userTriggered to false as this could well be programmatic
                });
              }
            },
            false,
            currentWindow
          )
        )
      );
    }
    return callbackWrapper(() => {
      handlers.forEach((h) => h());
    });
  }
  function getNestedCSSRulePositions(rule2) {
    const positions = [];
    function recurse(childRule, pos) {
      if (hasNestedCSSRule("CSSGroupingRule") && childRule.parentRule instanceof CSSGroupingRule || hasNestedCSSRule("CSSMediaRule") && childRule.parentRule instanceof CSSMediaRule || hasNestedCSSRule("CSSSupportsRule") && childRule.parentRule instanceof CSSSupportsRule || hasNestedCSSRule("CSSConditionRule") && childRule.parentRule instanceof CSSConditionRule) {
        const rules2 = Array.from(
          childRule.parentRule.cssRules
        );
        const index2 = rules2.indexOf(childRule);
        pos.unshift(index2);
      } else if (childRule.parentStyleSheet) {
        const rules2 = Array.from(childRule.parentStyleSheet.cssRules);
        const index2 = rules2.indexOf(childRule);
        pos.unshift(index2);
      }
      return pos;
    }
    return recurse(rule2, positions);
  }
  function getIdAndStyleId(sheet, mirror2, styleMirror) {
    let id, styleId;
    if (!sheet) return {};
    if (sheet.ownerNode) id = mirror2.getId(sheet.ownerNode);
    else styleId = styleMirror.getId(sheet);
    return {
      styleId,
      id
    };
  }
  function initStyleSheetObserver({ styleSheetRuleCb, mirror: mirror2, stylesheetManager }, { win }) {
    if (!win.CSSStyleSheet || !win.CSSStyleSheet.prototype) {
      return () => {
      };
    }
    const insertRule = win.CSSStyleSheet.prototype.insertRule;
    win.CSSStyleSheet.prototype.insertRule = new Proxy(insertRule, {
      apply: callbackWrapper(
        (target, thisArg, argumentsList) => {
          const [rule2, index2] = argumentsList;
          const { id, styleId } = getIdAndStyleId(
            thisArg,
            mirror2,
            stylesheetManager.styleMirror
          );
          if (id && id !== -1 || styleId && styleId !== -1) {
            styleSheetRuleCb({
              id,
              styleId,
              adds: [{ rule: rule2, index: index2 }]
            });
          }
          return target.apply(thisArg, argumentsList);
        }
      )
    });
    win.CSSStyleSheet.prototype.addRule = function(selector, styleBlock, index2 = this.cssRules.length) {
      const rule2 = `${selector} { ${styleBlock} }`;
      return win.CSSStyleSheet.prototype.insertRule.apply(this, [rule2, index2]);
    };
    const deleteRule = win.CSSStyleSheet.prototype.deleteRule;
    win.CSSStyleSheet.prototype.deleteRule = new Proxy(deleteRule, {
      apply: callbackWrapper(
        (target, thisArg, argumentsList) => {
          const [index2] = argumentsList;
          const { id, styleId } = getIdAndStyleId(
            thisArg,
            mirror2,
            stylesheetManager.styleMirror
          );
          if (id && id !== -1 || styleId && styleId !== -1) {
            styleSheetRuleCb({
              id,
              styleId,
              removes: [{ index: index2 }]
            });
          }
          return target.apply(thisArg, argumentsList);
        }
      )
    });
    win.CSSStyleSheet.prototype.removeRule = function(index2) {
      return win.CSSStyleSheet.prototype.deleteRule.apply(this, [index2]);
    };
    let replace;
    if (win.CSSStyleSheet.prototype.replace) {
      replace = win.CSSStyleSheet.prototype.replace;
      win.CSSStyleSheet.prototype.replace = new Proxy(replace, {
        apply: callbackWrapper(
          (target, thisArg, argumentsList) => {
            const [text] = argumentsList;
            const { id, styleId } = getIdAndStyleId(
              thisArg,
              mirror2,
              stylesheetManager.styleMirror
            );
            if (id && id !== -1 || styleId && styleId !== -1) {
              styleSheetRuleCb({
                id,
                styleId,
                replace: text
              });
            }
            return target.apply(thisArg, argumentsList);
          }
        )
      });
    }
    let replaceSync;
    if (win.CSSStyleSheet.prototype.replaceSync) {
      replaceSync = win.CSSStyleSheet.prototype.replaceSync;
      win.CSSStyleSheet.prototype.replaceSync = new Proxy(replaceSync, {
        apply: callbackWrapper(
          (target, thisArg, argumentsList) => {
            const [text] = argumentsList;
            const { id, styleId } = getIdAndStyleId(
              thisArg,
              mirror2,
              stylesheetManager.styleMirror
            );
            if (id && id !== -1 || styleId && styleId !== -1) {
              styleSheetRuleCb({
                id,
                styleId,
                replaceSync: text
              });
            }
            return target.apply(thisArg, argumentsList);
          }
        )
      });
    }
    const supportedNestedCSSRuleTypes = {};
    if (canMonkeyPatchNestedCSSRule("CSSGroupingRule")) {
      supportedNestedCSSRuleTypes.CSSGroupingRule = win.CSSGroupingRule;
    } else {
      if (canMonkeyPatchNestedCSSRule("CSSMediaRule")) {
        supportedNestedCSSRuleTypes.CSSMediaRule = win.CSSMediaRule;
      }
      if (canMonkeyPatchNestedCSSRule("CSSConditionRule")) {
        supportedNestedCSSRuleTypes.CSSConditionRule = win.CSSConditionRule;
      }
      if (canMonkeyPatchNestedCSSRule("CSSSupportsRule")) {
        supportedNestedCSSRuleTypes.CSSSupportsRule = win.CSSSupportsRule;
      }
    }
    const unmodifiedFunctions = {};
    Object.entries(supportedNestedCSSRuleTypes).forEach(([typeKey, type]) => {
      unmodifiedFunctions[typeKey] = {
        // eslint-disable-next-line @typescript-eslint/unbound-method
        insertRule: type.prototype.insertRule,
        // eslint-disable-next-line @typescript-eslint/unbound-method
        deleteRule: type.prototype.deleteRule
      };
      type.prototype.insertRule = new Proxy(
        unmodifiedFunctions[typeKey].insertRule,
        {
          apply: callbackWrapper(
            (target, thisArg, argumentsList) => {
              const [rule2, index2] = argumentsList;
              const { id, styleId } = getIdAndStyleId(
                thisArg.parentStyleSheet,
                mirror2,
                stylesheetManager.styleMirror
              );
              if (id && id !== -1 || styleId && styleId !== -1) {
                styleSheetRuleCb({
                  id,
                  styleId,
                  adds: [
                    {
                      rule: rule2,
                      index: [
                        ...getNestedCSSRulePositions(thisArg),
                        index2 || 0
                        // defaults to 0
                      ]
                    }
                  ]
                });
              }
              return target.apply(thisArg, argumentsList);
            }
          )
        }
      );
      type.prototype.deleteRule = new Proxy(
        unmodifiedFunctions[typeKey].deleteRule,
        {
          apply: callbackWrapper(
            (target, thisArg, argumentsList) => {
              const [index2] = argumentsList;
              const { id, styleId } = getIdAndStyleId(
                thisArg.parentStyleSheet,
                mirror2,
                stylesheetManager.styleMirror
              );
              if (id && id !== -1 || styleId && styleId !== -1) {
                styleSheetRuleCb({
                  id,
                  styleId,
                  removes: [
                    { index: [...getNestedCSSRulePositions(thisArg), index2] }
                  ]
                });
              }
              return target.apply(thisArg, argumentsList);
            }
          )
        }
      );
    });
    return callbackWrapper(() => {
      win.CSSStyleSheet.prototype.insertRule = insertRule;
      win.CSSStyleSheet.prototype.deleteRule = deleteRule;
      replace && (win.CSSStyleSheet.prototype.replace = replace);
      replaceSync && (win.CSSStyleSheet.prototype.replaceSync = replaceSync);
      Object.entries(supportedNestedCSSRuleTypes).forEach(([typeKey, type]) => {
        type.prototype.insertRule = unmodifiedFunctions[typeKey].insertRule;
        type.prototype.deleteRule = unmodifiedFunctions[typeKey].deleteRule;
      });
    });
  }
  function initAdoptedStyleSheetObserver({
    mirror: mirror2,
    stylesheetManager
  }, host2) {
    var _a2, _b, _c;
    let hostId = null;
    if (host2.nodeName === "#document") hostId = mirror2.getId(host2);
    else hostId = mirror2.getId(index.host(host2));
    const patchTarget = host2.nodeName === "#document" ? (_a2 = host2.defaultView) == null ? void 0 : _a2.Document : (_c = (_b = host2.ownerDocument) == null ? void 0 : _b.defaultView) == null ? void 0 : _c.ShadowRoot;
    const originalPropertyDescriptor = (patchTarget == null ? void 0 : patchTarget.prototype) ? Object.getOwnPropertyDescriptor(
      patchTarget == null ? void 0 : patchTarget.prototype,
      "adoptedStyleSheets"
    ) : void 0;
    if (hostId === null || hostId === -1 || !patchTarget || !originalPropertyDescriptor)
      return () => {
      };
    Object.defineProperty(host2, "adoptedStyleSheets", {
      configurable: originalPropertyDescriptor.configurable,
      enumerable: originalPropertyDescriptor.enumerable,
      get() {
        var _a3;
        return (_a3 = originalPropertyDescriptor.get) == null ? void 0 : _a3.call(this);
      },
      set(sheets) {
        var _a3;
        const result2 = (_a3 = originalPropertyDescriptor.set) == null ? void 0 : _a3.call(this, sheets);
        if (hostId !== null && hostId !== -1) {
          try {
            stylesheetManager.adoptStyleSheets(sheets, hostId);
          } catch (e2) {
          }
        }
        return result2;
      }
    });
    return callbackWrapper(() => {
      Object.defineProperty(host2, "adoptedStyleSheets", {
        configurable: originalPropertyDescriptor.configurable,
        enumerable: originalPropertyDescriptor.enumerable,
        // eslint-disable-next-line @typescript-eslint/unbound-method
        get: originalPropertyDescriptor.get,
        // eslint-disable-next-line @typescript-eslint/unbound-method
        set: originalPropertyDescriptor.set
      });
    });
  }
  function initStyleDeclarationObserver({
    styleDeclarationCb,
    mirror: mirror2,
    ignoreCSSAttributes,
    stylesheetManager
  }, { win }) {
    const setProperty = win.CSSStyleDeclaration.prototype.setProperty;
    win.CSSStyleDeclaration.prototype.setProperty = new Proxy(setProperty, {
      apply: callbackWrapper(
        (target, thisArg, argumentsList) => {
          var _a2;
          const [property, value, priority] = argumentsList;
          if (ignoreCSSAttributes.has(property)) {
            return setProperty.apply(thisArg, [property, value, priority]);
          }
          const { id, styleId } = getIdAndStyleId(
            (_a2 = thisArg.parentRule) == null ? void 0 : _a2.parentStyleSheet,
            mirror2,
            stylesheetManager.styleMirror
          );
          if (id && id !== -1 || styleId && styleId !== -1) {
            styleDeclarationCb({
              id,
              styleId,
              set: {
                property,
                value,
                priority
              },
              // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
              index: getNestedCSSRulePositions(thisArg.parentRule)
            });
          }
          return target.apply(thisArg, argumentsList);
        }
      )
    });
    const removeProperty = win.CSSStyleDeclaration.prototype.removeProperty;
    win.CSSStyleDeclaration.prototype.removeProperty = new Proxy(removeProperty, {
      apply: callbackWrapper(
        (target, thisArg, argumentsList) => {
          var _a2;
          const [property] = argumentsList;
          if (ignoreCSSAttributes.has(property)) {
            return removeProperty.apply(thisArg, [property]);
          }
          const { id, styleId } = getIdAndStyleId(
            (_a2 = thisArg.parentRule) == null ? void 0 : _a2.parentStyleSheet,
            mirror2,
            stylesheetManager.styleMirror
          );
          if (id && id !== -1 || styleId && styleId !== -1) {
            styleDeclarationCb({
              id,
              styleId,
              remove: {
                property
              },
              // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
              index: getNestedCSSRulePositions(thisArg.parentRule)
            });
          }
          return target.apply(thisArg, argumentsList);
        }
      )
    });
    return callbackWrapper(() => {
      win.CSSStyleDeclaration.prototype.setProperty = setProperty;
      win.CSSStyleDeclaration.prototype.removeProperty = removeProperty;
    });
  }
  function initMediaInteractionObserver({
    mediaInteractionCb,
    blockClass,
    blockSelector,
    mirror: mirror2,
    sampling,
    doc
  }) {
    const handler = callbackWrapper(
      (type) => throttle(
        callbackWrapper((event) => {
          const target = getEventTarget(event);
          if (!target || isBlocked(target, blockClass, blockSelector, true)) {
            return;
          }
          const { currentTime, volume, muted, playbackRate, loop } = target;
          mediaInteractionCb({
            type,
            id: mirror2.getId(target),
            currentTime,
            volume,
            muted,
            playbackRate,
            loop
          });
        }),
        sampling.media || 500
      )
    );
    const handlers = [
      on("play", handler(MediaInteractions.Play), doc),
      on("pause", handler(MediaInteractions.Pause), doc),
      on("seeked", handler(MediaInteractions.Seeked), doc),
      on("volumechange", handler(MediaInteractions.VolumeChange), doc),
      on("ratechange", handler(MediaInteractions.RateChange), doc)
    ];
    return callbackWrapper(() => {
      handlers.forEach((h) => h());
    });
  }
  function initFontObserver({ fontCb, doc }) {
    const win = doc.defaultView;
    if (!win) {
      return () => {
      };
    }
    const handlers = [];
    const fontMap = /* @__PURE__ */ new WeakMap();
    const originalFontFace = win.FontFace;
    win.FontFace = function FontFace2(family, source, descriptors) {
      const fontFace = new originalFontFace(family, source, descriptors);
      fontMap.set(fontFace, {
        family,
        buffer: typeof source !== "string",
        descriptors,
        fontSource: typeof source === "string" ? source : JSON.stringify(Array.from(new Uint8Array(source)))
      });
      return fontFace;
    };
    const restoreHandler = patch(
      doc.fonts,
      "add",
      function(original) {
        return function(fontFace) {
          setTimeout(
            callbackWrapper(() => {
              const p = fontMap.get(fontFace);
              if (p) {
                fontCb(p);
                fontMap.delete(fontFace);
              }
            }),
            0
          );
          return original.apply(this, [fontFace]);
        };
      }
    );
    handlers.push(() => {
      win.FontFace = originalFontFace;
    });
    handlers.push(restoreHandler);
    return callbackWrapper(() => {
      handlers.forEach((h) => h());
    });
  }
  function initSelectionObserver(param) {
    const { doc, mirror: mirror2, blockClass, blockSelector, selectionCb } = param;
    let collapsed = true;
    const updateSelection = callbackWrapper(() => {
      const selection = doc.getSelection();
      if (!selection || collapsed && (selection == null ? void 0 : selection.isCollapsed)) return;
      collapsed = selection.isCollapsed || false;
      const ranges = [];
      const count = selection.rangeCount || 0;
      for (let i2 = 0; i2 < count; i2++) {
        const range = selection.getRangeAt(i2);
        const { startContainer, startOffset, endContainer, endOffset } = range;
        const blocked = isBlocked(startContainer, blockClass, blockSelector, true) || isBlocked(endContainer, blockClass, blockSelector, true);
        if (blocked) continue;
        ranges.push({
          start: mirror2.getId(startContainer),
          startOffset,
          end: mirror2.getId(endContainer),
          endOffset
        });
      }
      selectionCb({ ranges });
    });
    updateSelection();
    return on("selectionchange", updateSelection);
  }
  function initCustomElementObserver({
    doc,
    customElementCb
  }) {
    const win = doc.defaultView;
    if (!win || !win.customElements) return () => {
    };
    const restoreHandler = patch(
      win.customElements,
      "define",
      function(original) {
        return function(name, constructor, options) {
          try {
            customElementCb({
              define: {
                name
              }
            });
          } catch (e2) {
            console.warn(`Custom element callback failed for ${name}`);
          }
          return original.apply(this, [name, constructor, options]);
        };
      }
    );
    return restoreHandler;
  }
  function mergeHooks(o2, hooks) {
    const {
      mutationCb,
      mousemoveCb,
      mouseInteractionCb,
      scrollCb,
      viewportResizeCb,
      inputCb,
      mediaInteractionCb,
      styleSheetRuleCb,
      styleDeclarationCb,
      canvasMutationCb,
      fontCb,
      selectionCb,
      customElementCb
    } = o2;
    o2.mutationCb = (...p) => {
      if (hooks.mutation) {
        hooks.mutation(...p);
      }
      mutationCb(...p);
    };
    o2.mousemoveCb = (...p) => {
      if (hooks.mousemove) {
        hooks.mousemove(...p);
      }
      mousemoveCb(...p);
    };
    o2.mouseInteractionCb = (...p) => {
      if (hooks.mouseInteraction) {
        hooks.mouseInteraction(...p);
      }
      mouseInteractionCb(...p);
    };
    o2.scrollCb = (...p) => {
      if (hooks.scroll) {
        hooks.scroll(...p);
      }
      scrollCb(...p);
    };
    o2.viewportResizeCb = (...p) => {
      if (hooks.viewportResize) {
        hooks.viewportResize(...p);
      }
      viewportResizeCb(...p);
    };
    o2.inputCb = (...p) => {
      if (hooks.input) {
        hooks.input(...p);
      }
      inputCb(...p);
    };
    o2.mediaInteractionCb = (...p) => {
      if (hooks.mediaInteaction) {
        hooks.mediaInteaction(...p);
      }
      mediaInteractionCb(...p);
    };
    o2.styleSheetRuleCb = (...p) => {
      if (hooks.styleSheetRule) {
        hooks.styleSheetRule(...p);
      }
      styleSheetRuleCb(...p);
    };
    o2.styleDeclarationCb = (...p) => {
      if (hooks.styleDeclaration) {
        hooks.styleDeclaration(...p);
      }
      styleDeclarationCb(...p);
    };
    o2.canvasMutationCb = (...p) => {
      if (hooks.canvasMutation) {
        hooks.canvasMutation(...p);
      }
      canvasMutationCb(...p);
    };
    o2.fontCb = (...p) => {
      if (hooks.font) {
        hooks.font(...p);
      }
      fontCb(...p);
    };
    o2.selectionCb = (...p) => {
      if (hooks.selection) {
        hooks.selection(...p);
      }
      selectionCb(...p);
    };
    o2.customElementCb = (...c2) => {
      if (hooks.customElement) {
        hooks.customElement(...c2);
      }
      customElementCb(...c2);
    };
  }
  function initObservers(o2, hooks = {}) {
    const currentWindow = o2.doc.defaultView;
    if (!currentWindow) {
      return () => {
      };
    }
    mergeHooks(o2, hooks);
    let mutationObserver;
    if (o2.recordDOM) {
      mutationObserver = initMutationObserver(o2, o2.doc);
    }
    const mousemoveHandler = initMoveObserver(o2);
    const mouseInteractionHandler = initMouseInteractionObserver(o2);
    const scrollHandler = initScrollObserver(o2);
    const viewportResizeHandler = initViewportResizeObserver(o2, {
      win: currentWindow
    });
    const inputHandler = initInputObserver(o2);
    const mediaInteractionHandler = initMediaInteractionObserver(o2);
    let styleSheetObserver = () => {
    };
    let adoptedStyleSheetObserver = () => {
    };
    let styleDeclarationObserver = () => {
    };
    let fontObserver = () => {
    };
    if (o2.recordDOM) {
      styleSheetObserver = initStyleSheetObserver(o2, { win: currentWindow });
      adoptedStyleSheetObserver = initAdoptedStyleSheetObserver(o2, o2.doc);
      styleDeclarationObserver = initStyleDeclarationObserver(o2, {
        win: currentWindow
      });
      if (o2.collectFonts) {
        fontObserver = initFontObserver(o2);
      }
    }
    const selectionObserver = initSelectionObserver(o2);
    const customElementObserver = initCustomElementObserver(o2);
    const pluginHandlers = [];
    for (const plugin3 of o2.plugins) {
      pluginHandlers.push(
        plugin3.observer(plugin3.callback, currentWindow, plugin3.options)
      );
    }
    return callbackWrapper(() => {
      mutationBuffers.forEach((b) => b.reset());
      mutationObserver == null ? void 0 : mutationObserver.disconnect();
      mousemoveHandler();
      mouseInteractionHandler();
      scrollHandler();
      viewportResizeHandler();
      inputHandler();
      mediaInteractionHandler();
      styleSheetObserver();
      adoptedStyleSheetObserver();
      styleDeclarationObserver();
      fontObserver();
      selectionObserver();
      customElementObserver();
      pluginHandlers.forEach((h) => h());
    });
  }
  function hasNestedCSSRule(prop) {
    return typeof window[prop] !== "undefined";
  }
  function canMonkeyPatchNestedCSSRule(prop) {
    return Boolean(
      typeof window[prop] !== "undefined" && // Note: Generally, this check _shouldn't_ be necessary
      // However, in some scenarios (e.g. jsdom) this can sometimes fail, so we check for it here
      window[prop].prototype && "insertRule" in window[prop].prototype && "deleteRule" in window[prop].prototype
    );
  }
  var CrossOriginIframeMirror = class {
    constructor(generateIdFn) {
      __publicField(this, "iframeIdToRemoteIdMap", /* @__PURE__ */ new WeakMap());
      __publicField(this, "iframeRemoteIdToIdMap", /* @__PURE__ */ new WeakMap());
      this.generateIdFn = generateIdFn;
    }
    getId(iframe, remoteId, idToRemoteMap, remoteToIdMap) {
      const idToRemoteIdMap = idToRemoteMap || this.getIdToRemoteIdMap(iframe);
      const remoteIdToIdMap = remoteToIdMap || this.getRemoteIdToIdMap(iframe);
      let id = idToRemoteIdMap.get(remoteId);
      if (!id) {
        id = this.generateIdFn();
        idToRemoteIdMap.set(remoteId, id);
        remoteIdToIdMap.set(id, remoteId);
      }
      return id;
    }
    getIds(iframe, remoteId) {
      const idToRemoteIdMap = this.getIdToRemoteIdMap(iframe);
      const remoteIdToIdMap = this.getRemoteIdToIdMap(iframe);
      return remoteId.map(
        (id) => this.getId(iframe, id, idToRemoteIdMap, remoteIdToIdMap)
      );
    }
    getRemoteId(iframe, id, map) {
      const remoteIdToIdMap = map || this.getRemoteIdToIdMap(iframe);
      if (typeof id !== "number") return id;
      const remoteId = remoteIdToIdMap.get(id);
      if (!remoteId) return -1;
      return remoteId;
    }
    getRemoteIds(iframe, ids) {
      const remoteIdToIdMap = this.getRemoteIdToIdMap(iframe);
      return ids.map((id) => this.getRemoteId(iframe, id, remoteIdToIdMap));
    }
    reset(iframe) {
      if (!iframe) {
        this.iframeIdToRemoteIdMap = /* @__PURE__ */ new WeakMap();
        this.iframeRemoteIdToIdMap = /* @__PURE__ */ new WeakMap();
        return;
      }
      this.iframeIdToRemoteIdMap.delete(iframe);
      this.iframeRemoteIdToIdMap.delete(iframe);
    }
    getIdToRemoteIdMap(iframe) {
      let idToRemoteIdMap = this.iframeIdToRemoteIdMap.get(iframe);
      if (!idToRemoteIdMap) {
        idToRemoteIdMap = /* @__PURE__ */ new Map();
        this.iframeIdToRemoteIdMap.set(iframe, idToRemoteIdMap);
      }
      return idToRemoteIdMap;
    }
    getRemoteIdToIdMap(iframe) {
      let remoteIdToIdMap = this.iframeRemoteIdToIdMap.get(iframe);
      if (!remoteIdToIdMap) {
        remoteIdToIdMap = /* @__PURE__ */ new Map();
        this.iframeRemoteIdToIdMap.set(iframe, remoteIdToIdMap);
      }
      return remoteIdToIdMap;
    }
  };
  var IframeManager = class {
    constructor(options) {
      __publicField(this, "iframes", /* @__PURE__ */ new WeakMap());
      __publicField(this, "crossOriginIframeMap", /* @__PURE__ */ new WeakMap());
      __publicField(this, "crossOriginIframeMirror", new CrossOriginIframeMirror(genId));
      __publicField(this, "crossOriginIframeStyleMirror");
      __publicField(this, "crossOriginIframeRootIdMap", /* @__PURE__ */ new WeakMap());
      __publicField(this, "mirror");
      __publicField(this, "mutationCb");
      __publicField(this, "wrappedEmit");
      __publicField(this, "loadListener");
      __publicField(this, "stylesheetManager");
      __publicField(this, "recordCrossOriginIframes");
      this.mutationCb = options.mutationCb;
      this.wrappedEmit = options.wrappedEmit;
      this.stylesheetManager = options.stylesheetManager;
      this.recordCrossOriginIframes = options.recordCrossOriginIframes;
      this.crossOriginIframeStyleMirror = new CrossOriginIframeMirror(
        this.stylesheetManager.styleMirror.generateId.bind(
          this.stylesheetManager.styleMirror
        )
      );
      this.mirror = options.mirror;
      if (this.recordCrossOriginIframes) {
        window.addEventListener("message", this.handleMessage.bind(this));
      }
    }
    addIframe(iframeEl) {
      this.iframes.set(iframeEl, true);
      if (iframeEl.contentWindow)
        this.crossOriginIframeMap.set(iframeEl.contentWindow, iframeEl);
    }
    addLoadListener(cb) {
      this.loadListener = cb;
    }
    attachIframe(iframeEl, childSn) {
      var _a2, _b;
      this.mutationCb({
        adds: [
          {
            parentId: this.mirror.getId(iframeEl),
            nextId: null,
            node: childSn
          }
        ],
        removes: [],
        texts: [],
        attributes: [],
        isAttachIframe: true
      });
      if (this.recordCrossOriginIframes)
        (_a2 = iframeEl.contentWindow) == null ? void 0 : _a2.addEventListener(
          "message",
          this.handleMessage.bind(this)
        );
      (_b = this.loadListener) == null ? void 0 : _b.call(this, iframeEl);
      if (iframeEl.contentDocument && iframeEl.contentDocument.adoptedStyleSheets && iframeEl.contentDocument.adoptedStyleSheets.length > 0)
        this.stylesheetManager.adoptStyleSheets(
          iframeEl.contentDocument.adoptedStyleSheets,
          this.mirror.getId(iframeEl.contentDocument)
        );
    }
    handleMessage(message) {
      const crossOriginMessageEvent = message;
      if (crossOriginMessageEvent.data.type !== "rrweb" || // To filter out the rrweb messages which are forwarded by some sites.
      crossOriginMessageEvent.origin !== crossOriginMessageEvent.data.origin)
        return;
      const iframeSourceWindow = message.source;
      if (!iframeSourceWindow) return;
      const iframeEl = this.crossOriginIframeMap.get(message.source);
      if (!iframeEl) return;
      const transformedEvent = this.transformCrossOriginEvent(
        iframeEl,
        crossOriginMessageEvent.data.event
      );
      if (transformedEvent)
        this.wrappedEmit(
          transformedEvent,
          crossOriginMessageEvent.data.isCheckout
        );
    }
    transformCrossOriginEvent(iframeEl, e2) {
      var _a2;
      switch (e2.type) {
        case EventType.FullSnapshot: {
          this.crossOriginIframeMirror.reset(iframeEl);
          this.crossOriginIframeStyleMirror.reset(iframeEl);
          this.replaceIdOnNode(e2.data.node, iframeEl);
          const rootId = e2.data.node.id;
          this.crossOriginIframeRootIdMap.set(iframeEl, rootId);
          this.patchRootIdOnNode(e2.data.node, rootId);
          return {
            timestamp: e2.timestamp,
            type: EventType.IncrementalSnapshot,
            data: {
              source: IncrementalSource.Mutation,
              adds: [
                {
                  parentId: this.mirror.getId(iframeEl),
                  nextId: null,
                  node: e2.data.node
                }
              ],
              removes: [],
              texts: [],
              attributes: [],
              isAttachIframe: true
            }
          };
        }
        case EventType.Meta:
        case EventType.Load:
        case EventType.DomContentLoaded: {
          return false;
        }
        case EventType.Plugin: {
          return e2;
        }
        case EventType.Custom: {
          this.replaceIds(
            e2.data.payload,
            iframeEl,
            ["id", "parentId", "previousId", "nextId"]
          );
          return e2;
        }
        case EventType.IncrementalSnapshot: {
          switch (e2.data.source) {
            case IncrementalSource.Mutation: {
              e2.data.adds.forEach((n2) => {
                this.replaceIds(n2, iframeEl, [
                  "parentId",
                  "nextId",
                  "previousId"
                ]);
                this.replaceIdOnNode(n2.node, iframeEl);
                const rootId = this.crossOriginIframeRootIdMap.get(iframeEl);
                rootId && this.patchRootIdOnNode(n2.node, rootId);
              });
              e2.data.removes.forEach((n2) => {
                this.replaceIds(n2, iframeEl, ["parentId", "id"]);
              });
              e2.data.attributes.forEach((n2) => {
                this.replaceIds(n2, iframeEl, ["id"]);
              });
              e2.data.texts.forEach((n2) => {
                this.replaceIds(n2, iframeEl, ["id"]);
              });
              return e2;
            }
            case IncrementalSource.Drag:
            case IncrementalSource.TouchMove:
            case IncrementalSource.MouseMove: {
              e2.data.positions.forEach((p) => {
                this.replaceIds(p, iframeEl, ["id"]);
              });
              return e2;
            }
            case IncrementalSource.ViewportResize: {
              return false;
            }
            case IncrementalSource.MediaInteraction:
            case IncrementalSource.MouseInteraction:
            case IncrementalSource.Scroll:
            case IncrementalSource.CanvasMutation:
            case IncrementalSource.Input: {
              this.replaceIds(e2.data, iframeEl, ["id"]);
              return e2;
            }
            case IncrementalSource.StyleSheetRule:
            case IncrementalSource.StyleDeclaration: {
              this.replaceIds(e2.data, iframeEl, ["id"]);
              this.replaceStyleIds(e2.data, iframeEl, ["styleId"]);
              return e2;
            }
            case IncrementalSource.Font: {
              return e2;
            }
            case IncrementalSource.Selection: {
              e2.data.ranges.forEach((range) => {
                this.replaceIds(range, iframeEl, ["start", "end"]);
              });
              return e2;
            }
            case IncrementalSource.AdoptedStyleSheet: {
              this.replaceIds(e2.data, iframeEl, ["id"]);
              this.replaceStyleIds(e2.data, iframeEl, ["styleIds"]);
              (_a2 = e2.data.styles) == null ? void 0 : _a2.forEach((style) => {
                this.replaceStyleIds(style, iframeEl, ["styleId"]);
              });
              return e2;
            }
          }
        }
      }
      return false;
    }
    replace(iframeMirror, obj, iframeEl, keys) {
      for (const key of keys) {
        if (!Array.isArray(obj[key]) && typeof obj[key] !== "number") continue;
        if (Array.isArray(obj[key])) {
          obj[key] = iframeMirror.getIds(
            iframeEl,
            obj[key]
          );
        } else {
          obj[key] = iframeMirror.getId(iframeEl, obj[key]);
        }
      }
      return obj;
    }
    replaceIds(obj, iframeEl, keys) {
      return this.replace(this.crossOriginIframeMirror, obj, iframeEl, keys);
    }
    replaceStyleIds(obj, iframeEl, keys) {
      return this.replace(this.crossOriginIframeStyleMirror, obj, iframeEl, keys);
    }
    replaceIdOnNode(node2, iframeEl) {
      this.replaceIds(node2, iframeEl, ["id", "rootId"]);
      if ("childNodes" in node2) {
        node2.childNodes.forEach((child) => {
          this.replaceIdOnNode(child, iframeEl);
        });
      }
    }
    patchRootIdOnNode(node2, rootId) {
      if (node2.type !== NodeType.Document && !node2.rootId) node2.rootId = rootId;
      if ("childNodes" in node2) {
        node2.childNodes.forEach((child) => {
          this.patchRootIdOnNode(child, rootId);
        });
      }
    }
  };
  var ShadowDomManager = class {
    constructor(options) {
      __publicField(this, "shadowDoms", /* @__PURE__ */ new WeakSet());
      __publicField(this, "mutationCb");
      __publicField(this, "scrollCb");
      __publicField(this, "bypassOptions");
      __publicField(this, "mirror");
      __publicField(this, "restoreHandlers", []);
      this.mutationCb = options.mutationCb;
      this.scrollCb = options.scrollCb;
      this.bypassOptions = options.bypassOptions;
      this.mirror = options.mirror;
      this.init();
    }
    init() {
      this.reset();
      this.patchAttachShadow(Element, document);
    }
    addShadowRoot(shadowRoot2, doc) {
      if (!isNativeShadowDom(shadowRoot2)) return;
      if (this.shadowDoms.has(shadowRoot2)) return;
      this.shadowDoms.add(shadowRoot2);
      const observer = initMutationObserver(
        {
          ...this.bypassOptions,
          doc,
          mutationCb: this.mutationCb,
          mirror: this.mirror,
          shadowDomManager: this
        },
        shadowRoot2
      );
      this.restoreHandlers.push(() => observer.disconnect());
      this.restoreHandlers.push(
        initScrollObserver({
          ...this.bypassOptions,
          scrollCb: this.scrollCb,
          // https://gist.github.com/praveenpuglia/0832da687ed5a5d7a0907046c9ef1813
          // scroll is not allowed to pass the boundary, so we need to listen the shadow document
          doc: shadowRoot2,
          mirror: this.mirror
        })
      );
      setTimeout(() => {
        if (shadowRoot2.adoptedStyleSheets && shadowRoot2.adoptedStyleSheets.length > 0)
          this.bypassOptions.stylesheetManager.adoptStyleSheets(
            shadowRoot2.adoptedStyleSheets,
            this.mirror.getId(index.host(shadowRoot2))
          );
        this.restoreHandlers.push(
          initAdoptedStyleSheetObserver(
            {
              mirror: this.mirror,
              stylesheetManager: this.bypassOptions.stylesheetManager
            },
            shadowRoot2
          )
        );
      }, 0);
    }
    /**
     * Monkey patch 'attachShadow' of an IFrameElement to observe newly added shadow doms.
     */
    observeAttachShadow(iframeElement) {
      if (!iframeElement.contentWindow || !iframeElement.contentDocument) return;
      this.patchAttachShadow(
        iframeElement.contentWindow.Element,
        iframeElement.contentDocument
      );
    }
    /**
     * Patch 'attachShadow' to observe newly added shadow doms.
     */
    patchAttachShadow(element, doc) {
      const manager = this;
      this.restoreHandlers.push(
        patch(
          element.prototype,
          "attachShadow",
          function(original) {
            return function(option) {
              const sRoot = original.call(this, option);
              const shadowRootEl = index.shadowRoot(this);
              if (shadowRootEl && inDom(this))
                manager.addShadowRoot(shadowRootEl, doc);
              return sRoot;
            };
          }
        )
      );
    }
    reset() {
      this.restoreHandlers.forEach((handler) => {
        try {
          handler();
        } catch (e2) {
        }
      });
      this.restoreHandlers = [];
      this.shadowDoms = /* @__PURE__ */ new WeakSet();
    }
  };
  var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  var lookup = typeof Uint8Array === "undefined" ? [] : new Uint8Array(256);
  for (i$1 = 0; i$1 < chars.length; i$1++) {
    lookup[chars.charCodeAt(i$1)] = i$1;
  }
  var i$1;
  var encode = function(arraybuffer) {
    var bytes = new Uint8Array(arraybuffer), i2, len = bytes.length, base64 = "";
    for (i2 = 0; i2 < len; i2 += 3) {
      base64 += chars[bytes[i2] >> 2];
      base64 += chars[(bytes[i2] & 3) << 4 | bytes[i2 + 1] >> 4];
      base64 += chars[(bytes[i2 + 1] & 15) << 2 | bytes[i2 + 2] >> 6];
      base64 += chars[bytes[i2 + 2] & 63];
    }
    if (len % 3 === 2) {
      base64 = base64.substring(0, base64.length - 1) + "=";
    } else if (len % 3 === 1) {
      base64 = base64.substring(0, base64.length - 2) + "==";
    }
    return base64;
  };
  var canvasVarMap = /* @__PURE__ */ new Map();
  function variableListFor$1(ctx, ctor) {
    let contextMap = canvasVarMap.get(ctx);
    if (!contextMap) {
      contextMap = /* @__PURE__ */ new Map();
      canvasVarMap.set(ctx, contextMap);
    }
    if (!contextMap.has(ctor)) {
      contextMap.set(ctor, []);
    }
    return contextMap.get(ctor);
  }
  var saveWebGLVar = (value, win, ctx) => {
    if (!value || !(isInstanceOfWebGLObject(value, win) || typeof value === "object"))
      return;
    const name = value.constructor.name;
    const list2 = variableListFor$1(ctx, name);
    let index2 = list2.indexOf(value);
    if (index2 === -1) {
      index2 = list2.length;
      list2.push(value);
    }
    return index2;
  };
  function serializeArg(value, win, ctx) {
    if (value instanceof Array) {
      return value.map((arg) => serializeArg(arg, win, ctx));
    } else if (value === null) {
      return value;
    } else if (value instanceof Float32Array || value instanceof Float64Array || value instanceof Int32Array || value instanceof Uint32Array || value instanceof Uint8Array || value instanceof Uint16Array || value instanceof Int16Array || value instanceof Int8Array || value instanceof Uint8ClampedArray) {
      const name = value.constructor.name;
      return {
        rr_type: name,
        args: [Object.values(value)]
      };
    } else if (
      // SharedArrayBuffer disabled on most browsers due to spectre.
      // More info: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer/SharedArrayBuffer
      // value instanceof SharedArrayBuffer ||
      value instanceof ArrayBuffer
    ) {
      const name = value.constructor.name;
      const base64 = encode(value);
      return {
        rr_type: name,
        base64
      };
    } else if (value instanceof DataView) {
      const name = value.constructor.name;
      return {
        rr_type: name,
        args: [
          serializeArg(value.buffer, win, ctx),
          value.byteOffset,
          value.byteLength
        ]
      };
    } else if (value instanceof HTMLImageElement) {
      const name = value.constructor.name;
      const { src } = value;
      return {
        rr_type: name,
        src
      };
    } else if (value instanceof HTMLCanvasElement) {
      const name = "HTMLImageElement";
      const src = value.toDataURL();
      return {
        rr_type: name,
        src
      };
    } else if (value instanceof ImageData) {
      const name = value.constructor.name;
      return {
        rr_type: name,
        args: [serializeArg(value.data, win, ctx), value.width, value.height]
      };
    } else if (isInstanceOfWebGLObject(value, win) || typeof value === "object") {
      const name = value.constructor.name;
      const index2 = saveWebGLVar(value, win, ctx);
      return {
        rr_type: name,
        index: index2
      };
    }
    return value;
  }
  var serializeArgs = (args, win, ctx) => {
    return args.map((arg) => serializeArg(arg, win, ctx));
  };
  var isInstanceOfWebGLObject = (value, win) => {
    const webGLConstructorNames = [
      "WebGLActiveInfo",
      "WebGLBuffer",
      "WebGLFramebuffer",
      "WebGLProgram",
      "WebGLRenderbuffer",
      "WebGLShader",
      "WebGLShaderPrecisionFormat",
      "WebGLTexture",
      "WebGLUniformLocation",
      "WebGLVertexArrayObject",
      // In old Chrome versions, value won't be an instanceof WebGLVertexArrayObject.
      "WebGLVertexArrayObjectOES"
    ];
    const supportedWebGLConstructorNames = webGLConstructorNames.filter(
      (name) => typeof win[name] === "function"
    );
    return Boolean(
      supportedWebGLConstructorNames.find(
        (name) => value instanceof win[name]
      )
    );
  };
  function initCanvas2DMutationObserver(cb, win, blockClass, blockSelector) {
    const handlers = [];
    const props2D = Object.getOwnPropertyNames(
      win.CanvasRenderingContext2D.prototype
    );
    for (const prop of props2D) {
      try {
        if (typeof win.CanvasRenderingContext2D.prototype[prop] !== "function") {
          continue;
        }
        const restoreHandler = patch(
          win.CanvasRenderingContext2D.prototype,
          prop,
          function(original) {
            return function(...args) {
              if (!isBlocked(this.canvas, blockClass, blockSelector, true)) {
                setTimeout(() => {
                  const recordArgs = serializeArgs(args, win, this);
                  cb(this.canvas, {
                    type: CanvasContext["2D"],
                    property: prop,
                    args: recordArgs
                  });
                }, 0);
              }
              return original.apply(this, args);
            };
          }
        );
        handlers.push(restoreHandler);
      } catch {
        const hookHandler = hookSetter(
          win.CanvasRenderingContext2D.prototype,
          prop,
          {
            set(v2) {
              cb(this.canvas, {
                type: CanvasContext["2D"],
                property: prop,
                args: [v2],
                setter: true
              });
            }
          }
        );
        handlers.push(hookHandler);
      }
    }
    return () => {
      handlers.forEach((h) => h());
    };
  }
  function getNormalizedContextName(contextType) {
    return contextType === "experimental-webgl" ? "webgl" : contextType;
  }
  function initCanvasContextObserver(win, blockClass, blockSelector, setPreserveDrawingBufferToTrue) {
    const handlers = [];
    try {
      const restoreHandler = patch(
        win.HTMLCanvasElement.prototype,
        "getContext",
        function(original) {
          return function(contextType, ...args) {
            if (!isBlocked(this, blockClass, blockSelector, true)) {
              const ctxName = getNormalizedContextName(contextType);
              if (!("__context" in this)) this.__context = ctxName;
              if (setPreserveDrawingBufferToTrue && ["webgl", "webgl2"].includes(ctxName)) {
                if (args[0] && typeof args[0] === "object") {
                  const contextAttributes = args[0];
                  if (!contextAttributes.preserveDrawingBuffer) {
                    contextAttributes.preserveDrawingBuffer = true;
                  }
                } else {
                  args.splice(0, 1, {
                    preserveDrawingBuffer: true
                  });
                }
              }
            }
            return original.apply(this, [contextType, ...args]);
          };
        }
      );
      handlers.push(restoreHandler);
    } catch {
      console.error("failed to patch HTMLCanvasElement.prototype.getContext");
    }
    return () => {
      handlers.forEach((h) => h());
    };
  }
  function patchGLPrototype(prototype, type, cb, blockClass, blockSelector, win) {
    const handlers = [];
    const props = Object.getOwnPropertyNames(prototype);
    for (const prop of props) {
      if (
        //prop.startsWith('get') ||  // e.g. getProgramParameter, but too risky
        [
          "isContextLost",
          "canvas",
          "drawingBufferWidth",
          "drawingBufferHeight"
        ].includes(prop)
      ) {
        continue;
      }
      try {
        if (typeof prototype[prop] !== "function") {
          continue;
        }
        const restoreHandler = patch(
          prototype,
          prop,
          function(original) {
            return function(...args) {
              const result2 = original.apply(this, args);
              saveWebGLVar(result2, win, this);
              if ("tagName" in this.canvas && !isBlocked(this.canvas, blockClass, blockSelector, true)) {
                const recordArgs = serializeArgs(args, win, this);
                const mutation = {
                  type,
                  property: prop,
                  args: recordArgs
                };
                cb(this.canvas, mutation);
              }
              return result2;
            };
          }
        );
        handlers.push(restoreHandler);
      } catch {
        const hookHandler = hookSetter(prototype, prop, {
          set(v2) {
            cb(this.canvas, {
              type,
              property: prop,
              args: [v2],
              setter: true
            });
          }
        });
        handlers.push(hookHandler);
      }
    }
    return handlers;
  }
  function initCanvasWebGLMutationObserver(cb, win, blockClass, blockSelector) {
    const handlers = [];
    handlers.push(
      ...patchGLPrototype(
        win.WebGLRenderingContext.prototype,
        CanvasContext.WebGL,
        cb,
        blockClass,
        blockSelector,
        win
      )
    );
    if (typeof win.WebGL2RenderingContext !== "undefined") {
      handlers.push(
        ...patchGLPrototype(
          win.WebGL2RenderingContext.prototype,
          CanvasContext.WebGL2,
          cb,
          blockClass,
          blockSelector,
          win
        )
      );
    }
    return () => {
      handlers.forEach((h) => h());
    };
  }
  var encodedJs = "KGZ1bmN0aW9uKCkgewogICJ1c2Ugc3RyaWN0IjsKICB2YXIgY2hhcnMgPSAiQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVphYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ejAxMjM0NTY3ODkrLyI7CiAgdmFyIGxvb2t1cCA9IHR5cGVvZiBVaW50OEFycmF5ID09PSAidW5kZWZpbmVkIiA/IFtdIDogbmV3IFVpbnQ4QXJyYXkoMjU2KTsKICBmb3IgKHZhciBpID0gMDsgaSA8IGNoYXJzLmxlbmd0aDsgaSsrKSB7CiAgICBsb29rdXBbY2hhcnMuY2hhckNvZGVBdChpKV0gPSBpOwogIH0KICB2YXIgZW5jb2RlID0gZnVuY3Rpb24oYXJyYXlidWZmZXIpIHsKICAgIHZhciBieXRlcyA9IG5ldyBVaW50OEFycmF5KGFycmF5YnVmZmVyKSwgaTIsIGxlbiA9IGJ5dGVzLmxlbmd0aCwgYmFzZTY0ID0gIiI7CiAgICBmb3IgKGkyID0gMDsgaTIgPCBsZW47IGkyICs9IDMpIHsKICAgICAgYmFzZTY0ICs9IGNoYXJzW2J5dGVzW2kyXSA+PiAyXTsKICAgICAgYmFzZTY0ICs9IGNoYXJzWyhieXRlc1tpMl0gJiAzKSA8PCA0IHwgYnl0ZXNbaTIgKyAxXSA+PiA0XTsKICAgICAgYmFzZTY0ICs9IGNoYXJzWyhieXRlc1tpMiArIDFdICYgMTUpIDw8IDIgfCBieXRlc1tpMiArIDJdID4+IDZdOwogICAgICBiYXNlNjQgKz0gY2hhcnNbYnl0ZXNbaTIgKyAyXSAmIDYzXTsKICAgIH0KICAgIGlmIChsZW4gJSAzID09PSAyKSB7CiAgICAgIGJhc2U2NCA9IGJhc2U2NC5zdWJzdHJpbmcoMCwgYmFzZTY0Lmxlbmd0aCAtIDEpICsgIj0iOwogICAgfSBlbHNlIGlmIChsZW4gJSAzID09PSAxKSB7CiAgICAgIGJhc2U2NCA9IGJhc2U2NC5zdWJzdHJpbmcoMCwgYmFzZTY0Lmxlbmd0aCAtIDIpICsgIj09IjsKICAgIH0KICAgIHJldHVybiBiYXNlNjQ7CiAgfTsKICBjb25zdCBsYXN0QmxvYk1hcCA9IC8qIEBfX1BVUkVfXyAqLyBuZXcgTWFwKCk7CiAgY29uc3QgdHJhbnNwYXJlbnRCbG9iTWFwID0gLyogQF9fUFVSRV9fICovIG5ldyBNYXAoKTsKICBhc3luYyBmdW5jdGlvbiBnZXRUcmFuc3BhcmVudEJsb2JGb3Iod2lkdGgsIGhlaWdodCwgZGF0YVVSTE9wdGlvbnMpIHsKICAgIGNvbnN0IGlkID0gYCR7d2lkdGh9LSR7aGVpZ2h0fWA7CiAgICBpZiAoIk9mZnNjcmVlbkNhbnZhcyIgaW4gZ2xvYmFsVGhpcykgewogICAgICBpZiAodHJhbnNwYXJlbnRCbG9iTWFwLmhhcyhpZCkpIHJldHVybiB0cmFuc3BhcmVudEJsb2JNYXAuZ2V0KGlkKTsKICAgICAgY29uc3Qgb2Zmc2NyZWVuID0gbmV3IE9mZnNjcmVlbkNhbnZhcyh3aWR0aCwgaGVpZ2h0KTsKICAgICAgb2Zmc2NyZWVuLmdldENvbnRleHQoIjJkIik7CiAgICAgIGNvbnN0IGJsb2IgPSBhd2FpdCBvZmZzY3JlZW4uY29udmVydFRvQmxvYihkYXRhVVJMT3B0aW9ucyk7CiAgICAgIGNvbnN0IGFycmF5QnVmZmVyID0gYXdhaXQgYmxvYi5hcnJheUJ1ZmZlcigpOwogICAgICBjb25zdCBiYXNlNjQgPSBlbmNvZGUoYXJyYXlCdWZmZXIpOwogICAgICB0cmFuc3BhcmVudEJsb2JNYXAuc2V0KGlkLCBiYXNlNjQpOwogICAgICByZXR1cm4gYmFzZTY0OwogICAgfSBlbHNlIHsKICAgICAgcmV0dXJuICIiOwogICAgfQogIH0KICBjb25zdCB3b3JrZXIgPSBzZWxmOwogIHdvcmtlci5vbm1lc3NhZ2UgPSBhc3luYyBmdW5jdGlvbihlKSB7CiAgICBpZiAoIk9mZnNjcmVlbkNhbnZhcyIgaW4gZ2xvYmFsVGhpcykgewogICAgICBjb25zdCB7IGlkLCBiaXRtYXAsIHdpZHRoLCBoZWlnaHQsIGRhdGFVUkxPcHRpb25zIH0gPSBlLmRhdGE7CiAgICAgIGNvbnN0IHRyYW5zcGFyZW50QmFzZTY0ID0gZ2V0VHJhbnNwYXJlbnRCbG9iRm9yKAogICAgICAgIHdpZHRoLAogICAgICAgIGhlaWdodCwKICAgICAgICBkYXRhVVJMT3B0aW9ucwogICAgICApOwogICAgICBjb25zdCBvZmZzY3JlZW4gPSBuZXcgT2Zmc2NyZWVuQ2FudmFzKHdpZHRoLCBoZWlnaHQpOwogICAgICBjb25zdCBjdHggPSBvZmZzY3JlZW4uZ2V0Q29udGV4dCgiMmQiKTsKICAgICAgY3R4LmRyYXdJbWFnZShiaXRtYXAsIDAsIDApOwogICAgICBiaXRtYXAuY2xvc2UoKTsKICAgICAgY29uc3QgYmxvYiA9IGF3YWl0IG9mZnNjcmVlbi5jb252ZXJ0VG9CbG9iKGRhdGFVUkxPcHRpb25zKTsKICAgICAgY29uc3QgdHlwZSA9IGJsb2IudHlwZTsKICAgICAgY29uc3QgYXJyYXlCdWZmZXIgPSBhd2FpdCBibG9iLmFycmF5QnVmZmVyKCk7CiAgICAgIGNvbnN0IGJhc2U2NCA9IGVuY29kZShhcnJheUJ1ZmZlcik7CiAgICAgIGlmICghbGFzdEJsb2JNYXAuaGFzKGlkKSAmJiBhd2FpdCB0cmFuc3BhcmVudEJhc2U2NCA9PT0gYmFzZTY0KSB7CiAgICAgICAgbGFzdEJsb2JNYXAuc2V0KGlkLCBiYXNlNjQpOwogICAgICAgIHJldHVybiB3b3JrZXIucG9zdE1lc3NhZ2UoeyBpZCB9KTsKICAgICAgfQogICAgICBpZiAobGFzdEJsb2JNYXAuZ2V0KGlkKSA9PT0gYmFzZTY0KSByZXR1cm4gd29ya2VyLnBvc3RNZXNzYWdlKHsgaWQgfSk7CiAgICAgIHdvcmtlci5wb3N0TWVzc2FnZSh7CiAgICAgICAgaWQsCiAgICAgICAgdHlwZSwKICAgICAgICBiYXNlNjQsCiAgICAgICAgd2lkdGgsCiAgICAgICAgaGVpZ2h0CiAgICAgIH0pOwogICAgICBsYXN0QmxvYk1hcC5zZXQoaWQsIGJhc2U2NCk7CiAgICB9IGVsc2UgewogICAgICByZXR1cm4gd29ya2VyLnBvc3RNZXNzYWdlKHsgaWQ6IGUuZGF0YS5pZCB9KTsKICAgIH0KICB9Owp9KSgpOwovLyMgc291cmNlTWFwcGluZ1VSTD1pbWFnZS1iaXRtYXAtZGF0YS11cmwtd29ya2VyLUlKcEM3Z19iLmpzLm1hcAo=";
  var decodeBase64 = (base64) => Uint8Array.from(atob(base64), (c2) => c2.charCodeAt(0));
  var blob = typeof window !== "undefined" && window.Blob && new Blob([decodeBase64(encodedJs)], { type: "text/javascript;charset=utf-8" });
  function WorkerWrapper(options) {
    let objURL;
    try {
      objURL = blob && (window.URL || window.webkitURL).createObjectURL(blob);
      if (!objURL) throw "";
      const worker = new Worker(objURL, {
        name: options == null ? void 0 : options.name
      });
      worker.addEventListener("error", () => {
        (window.URL || window.webkitURL).revokeObjectURL(objURL);
      });
      return worker;
    } catch (e2) {
      return new Worker(
        "data:text/javascript;base64," + encodedJs,
        {
          name: options == null ? void 0 : options.name
        }
      );
    } finally {
      objURL && (window.URL || window.webkitURL).revokeObjectURL(objURL);
    }
  }
  var CanvasManager = class {
    constructor(options) {
      __publicField(this, "pendingCanvasMutations", /* @__PURE__ */ new Map());
      __publicField(this, "rafStamps", { latestId: 0, invokeId: null });
      __publicField(this, "mirror");
      __publicField(this, "mutationCb");
      __publicField(this, "resetObservers");
      __publicField(this, "frozen", false);
      __publicField(this, "locked", false);
      __publicField(this, "processMutation", (target, mutation) => {
        const newFrame = this.rafStamps.invokeId && this.rafStamps.latestId !== this.rafStamps.invokeId;
        if (newFrame || !this.rafStamps.invokeId)
          this.rafStamps.invokeId = this.rafStamps.latestId;
        if (!this.pendingCanvasMutations.has(target)) {
          this.pendingCanvasMutations.set(target, []);
        }
        this.pendingCanvasMutations.get(target).push(mutation);
      });
      const {
        sampling = "all",
        win,
        blockClass,
        blockSelector,
        recordCanvas,
        dataURLOptions
      } = options;
      this.mutationCb = options.mutationCb;
      this.mirror = options.mirror;
      if (recordCanvas && sampling === "all")
        this.initCanvasMutationObserver(win, blockClass, blockSelector);
      if (recordCanvas && typeof sampling === "number")
        this.initCanvasFPSObserver(sampling, win, blockClass, blockSelector, {
          dataURLOptions
        });
    }
    reset() {
      this.pendingCanvasMutations.clear();
      this.resetObservers && this.resetObservers();
    }
    freeze() {
      this.frozen = true;
    }
    unfreeze() {
      this.frozen = false;
    }
    lock() {
      this.locked = true;
    }
    unlock() {
      this.locked = false;
    }
    initCanvasFPSObserver(fps, win, blockClass, blockSelector, options) {
      const canvasContextReset = initCanvasContextObserver(
        win,
        blockClass,
        blockSelector,
        true
      );
      const snapshotInProgressMap = /* @__PURE__ */ new Map();
      const worker = new WorkerWrapper();
      worker.onmessage = (e2) => {
        const { id } = e2.data;
        snapshotInProgressMap.set(id, false);
        if (!("base64" in e2.data)) return;
        const { base64, type, width, height } = e2.data;
        this.mutationCb({
          id,
          type: CanvasContext["2D"],
          commands: [
            {
              property: "clearRect",
              // wipe canvas
              args: [0, 0, width, height]
            },
            {
              property: "drawImage",
              // draws (semi-transparent) image
              args: [
                {
                  rr_type: "ImageBitmap",
                  args: [
                    {
                      rr_type: "Blob",
                      data: [{ rr_type: "ArrayBuffer", base64 }],
                      type
                    }
                  ]
                },
                0,
                0
              ]
            }
          ]
        });
      };
      const timeBetweenSnapshots = 1e3 / fps;
      let lastSnapshotTime = 0;
      let rafId;
      const getCanvas = () => {
        const matchedCanvas = [];
        win.document.querySelectorAll("canvas").forEach((canvas) => {
          if (!isBlocked(canvas, blockClass, blockSelector, true)) {
            matchedCanvas.push(canvas);
          }
        });
        return matchedCanvas;
      };
      const takeCanvasSnapshots = (timestamp) => {
        if (lastSnapshotTime && timestamp - lastSnapshotTime < timeBetweenSnapshots) {
          rafId = requestAnimationFrame(takeCanvasSnapshots);
          return;
        }
        lastSnapshotTime = timestamp;
        getCanvas().forEach(async (canvas) => {
          var _a2;
          const id = this.mirror.getId(canvas);
          if (snapshotInProgressMap.get(id)) return;
          if (canvas.width === 0 || canvas.height === 0) return;
          snapshotInProgressMap.set(id, true);
          if (["webgl", "webgl2"].includes(canvas.__context)) {
            const context = canvas.getContext(canvas.__context);
            if (((_a2 = context == null ? void 0 : context.getContextAttributes()) == null ? void 0 : _a2.preserveDrawingBuffer) === false) {
              context.clear(context.COLOR_BUFFER_BIT);
            }
          }
          const bitmap = await createImageBitmap(canvas);
          worker.postMessage(
            {
              id,
              bitmap,
              width: canvas.width,
              height: canvas.height,
              dataURLOptions: options.dataURLOptions
            },
            [bitmap]
          );
        });
        rafId = requestAnimationFrame(takeCanvasSnapshots);
      };
      rafId = requestAnimationFrame(takeCanvasSnapshots);
      this.resetObservers = () => {
        canvasContextReset();
        cancelAnimationFrame(rafId);
      };
    }
    initCanvasMutationObserver(win, blockClass, blockSelector) {
      this.startRAFTimestamping();
      this.startPendingCanvasMutationFlusher();
      const canvasContextReset = initCanvasContextObserver(
        win,
        blockClass,
        blockSelector,
        false
      );
      const canvas2DReset = initCanvas2DMutationObserver(
        this.processMutation.bind(this),
        win,
        blockClass,
        blockSelector
      );
      const canvasWebGL1and2Reset = initCanvasWebGLMutationObserver(
        this.processMutation.bind(this),
        win,
        blockClass,
        blockSelector
      );
      this.resetObservers = () => {
        canvasContextReset();
        canvas2DReset();
        canvasWebGL1and2Reset();
      };
    }
    startPendingCanvasMutationFlusher() {
      requestAnimationFrame(() => this.flushPendingCanvasMutations());
    }
    startRAFTimestamping() {
      const setLatestRAFTimestamp = (timestamp) => {
        this.rafStamps.latestId = timestamp;
        requestAnimationFrame(setLatestRAFTimestamp);
      };
      requestAnimationFrame(setLatestRAFTimestamp);
    }
    flushPendingCanvasMutations() {
      this.pendingCanvasMutations.forEach(
        (_values, canvas) => {
          const id = this.mirror.getId(canvas);
          this.flushPendingCanvasMutationFor(canvas, id);
        }
      );
      requestAnimationFrame(() => this.flushPendingCanvasMutations());
    }
    flushPendingCanvasMutationFor(canvas, id) {
      if (this.frozen || this.locked) {
        return;
      }
      const valuesWithType = this.pendingCanvasMutations.get(canvas);
      if (!valuesWithType || id === -1) return;
      const values = valuesWithType.map((value) => {
        const { type: type2, ...rest } = value;
        return rest;
      });
      const { type } = valuesWithType[0];
      this.mutationCb({ id, type, commands: values });
      this.pendingCanvasMutations.delete(canvas);
    }
  };
  var StylesheetManager = class {
    constructor(options) {
      __publicField(this, "trackedLinkElements", /* @__PURE__ */ new WeakSet());
      __publicField(this, "mutationCb");
      __publicField(this, "adoptedStyleSheetCb");
      __publicField(this, "styleMirror", new StyleSheetMirror());
      this.mutationCb = options.mutationCb;
      this.adoptedStyleSheetCb = options.adoptedStyleSheetCb;
    }
    attachLinkElement(linkEl, childSn) {
      if ("_cssText" in childSn.attributes)
        this.mutationCb({
          adds: [],
          removes: [],
          texts: [],
          attributes: [
            {
              id: childSn.id,
              attributes: childSn.attributes
            }
          ]
        });
      this.trackLinkElement(linkEl);
    }
    trackLinkElement(linkEl) {
      if (this.trackedLinkElements.has(linkEl)) return;
      this.trackedLinkElements.add(linkEl);
      this.trackStylesheetInLinkElement(linkEl);
    }
    adoptStyleSheets(sheets, hostId) {
      if (sheets.length === 0) return;
      const adoptedStyleSheetData = {
        id: hostId,
        styleIds: []
      };
      const styles = [];
      for (const sheet of sheets) {
        let styleId;
        if (!this.styleMirror.has(sheet)) {
          styleId = this.styleMirror.add(sheet);
          styles.push({
            styleId,
            rules: Array.from(sheet.rules || CSSRule, (r2, index2) => ({
              rule: stringifyRule(r2, sheet.href),
              index: index2
            }))
          });
        } else styleId = this.styleMirror.getId(sheet);
        adoptedStyleSheetData.styleIds.push(styleId);
      }
      if (styles.length > 0) adoptedStyleSheetData.styles = styles;
      this.adoptedStyleSheetCb(adoptedStyleSheetData);
    }
    reset() {
      this.styleMirror.reset();
      this.trackedLinkElements = /* @__PURE__ */ new WeakSet();
    }
    // TODO: take snapshot on stylesheet reload by applying event listener
    trackStylesheetInLinkElement(_linkEl) {
    }
  };
  var ProcessedNodeManager = class {
    constructor() {
      __publicField(this, "nodeMap", /* @__PURE__ */ new WeakMap());
      __publicField(this, "active", false);
    }
    inOtherBuffer(node2, thisBuffer) {
      const buffers = this.nodeMap.get(node2);
      return buffers && Array.from(buffers).some((buffer) => buffer !== thisBuffer);
    }
    add(node2, buffer) {
      if (!this.active) {
        this.active = true;
        requestAnimationFrame(() => {
          this.nodeMap = /* @__PURE__ */ new WeakMap();
          this.active = false;
        });
      }
      this.nodeMap.set(node2, (this.nodeMap.get(node2) || /* @__PURE__ */ new Set()).add(buffer));
    }
    destroy() {
    }
  };
  var wrappedEmit;
  var takeFullSnapshot$1;
  var canvasManager;
  var recording = false;
  try {
    if (Array.from([1], (x2) => x2 * 2)[0] !== 2) {
      const cleanFrame = document.createElement("iframe");
      document.body.appendChild(cleanFrame);
      Array.from = ((_a = cleanFrame.contentWindow) == null ? void 0 : _a.Array.from) || Array.from;
      document.body.removeChild(cleanFrame);
    }
  } catch (err) {
    console.debug("Unable to override Array.from", err);
  }
  var mirror = createMirror$2();
  function record(options = {}) {
    const {
      emit,
      checkoutEveryNms,
      checkoutEveryNth,
      blockClass = "rr-block",
      blockSelector = null,
      ignoreClass = "rr-ignore",
      ignoreSelector = null,
      maskTextClass = "rr-mask",
      maskTextSelector = null,
      inlineStylesheet = true,
      maskAllInputs,
      maskInputOptions: _maskInputOptions,
      slimDOMOptions: _slimDOMOptions,
      maskInputFn,
      maskTextFn,
      hooks,
      packFn,
      sampling = {},
      dataURLOptions = {},
      mousemoveWait,
      recordDOM = true,
      recordCanvas = false,
      recordCrossOriginIframes = false,
      recordAfter = options.recordAfter === "DOMContentLoaded" ? options.recordAfter : "load",
      userTriggeredOnInput = false,
      collectFonts = false,
      inlineImages = false,
      plugins,
      keepIframeSrcFn = () => false,
      ignoreCSSAttributes = /* @__PURE__ */ new Set([]),
      errorHandler: errorHandler2
    } = options;
    registerErrorHandler(errorHandler2);
    const inEmittingFrame = recordCrossOriginIframes ? window.parent === window : true;
    let passEmitsToParent = false;
    if (!inEmittingFrame) {
      try {
        if (window.parent.document) {
          passEmitsToParent = false;
        }
      } catch (e2) {
        passEmitsToParent = true;
      }
    }
    if (inEmittingFrame && !emit) {
      throw new Error("emit function is required");
    }
    if (!inEmittingFrame && !passEmitsToParent) {
      return () => {
      };
    }
    if (mousemoveWait !== void 0 && sampling.mousemove === void 0) {
      sampling.mousemove = mousemoveWait;
    }
    mirror.reset();
    const maskInputOptions = maskAllInputs === true ? {
      color: true,
      date: true,
      "datetime-local": true,
      email: true,
      month: true,
      number: true,
      range: true,
      search: true,
      tel: true,
      text: true,
      time: true,
      url: true,
      week: true,
      textarea: true,
      select: true,
      password: true
    } : _maskInputOptions !== void 0 ? _maskInputOptions : { password: true };
    const slimDOMOptions = slimDOMDefaults(_slimDOMOptions);
    polyfill$1();
    let lastFullSnapshotEvent;
    let incrementalSnapshotCount = 0;
    const eventProcessor = (e2) => {
      for (const plugin3 of plugins || []) {
        if (plugin3.eventProcessor) {
          e2 = plugin3.eventProcessor(e2);
        }
      }
      if (packFn && // Disable packing events which will be emitted to parent frames.
      !passEmitsToParent) {
        e2 = packFn(e2);
      }
      return e2;
    };
    wrappedEmit = (r2, isCheckout) => {
      var _a2;
      const e2 = r2;
      e2.timestamp = nowTimestamp();
      if (((_a2 = mutationBuffers[0]) == null ? void 0 : _a2.isFrozen()) && e2.type !== EventType.FullSnapshot && !(e2.type === EventType.IncrementalSnapshot && e2.data.source === IncrementalSource.Mutation)) {
        mutationBuffers.forEach((buf) => buf.unfreeze());
      }
      if (inEmittingFrame) {
        emit == null ? void 0 : emit(eventProcessor(e2), isCheckout);
      } else if (passEmitsToParent) {
        const message = {
          type: "rrweb",
          event: eventProcessor(e2),
          origin: window.location.origin,
          isCheckout
        };
        window.parent.postMessage(message, "*");
      }
      if (e2.type === EventType.FullSnapshot) {
        lastFullSnapshotEvent = e2;
        incrementalSnapshotCount = 0;
      } else if (e2.type === EventType.IncrementalSnapshot) {
        if (e2.data.source === IncrementalSource.Mutation && e2.data.isAttachIframe) {
          return;
        }
        incrementalSnapshotCount++;
        const exceedCount = checkoutEveryNth && incrementalSnapshotCount >= checkoutEveryNth;
        const exceedTime = checkoutEveryNms && e2.timestamp - lastFullSnapshotEvent.timestamp > checkoutEveryNms;
        if (exceedCount || exceedTime) {
          takeFullSnapshot$1(true);
        }
      }
    };
    const wrappedMutationEmit = (m) => {
      wrappedEmit({
        type: EventType.IncrementalSnapshot,
        data: {
          source: IncrementalSource.Mutation,
          ...m
        }
      });
    };
    const wrappedScrollEmit = (p) => wrappedEmit({
      type: EventType.IncrementalSnapshot,
      data: {
        source: IncrementalSource.Scroll,
        ...p
      }
    });
    const wrappedCanvasMutationEmit = (p) => wrappedEmit({
      type: EventType.IncrementalSnapshot,
      data: {
        source: IncrementalSource.CanvasMutation,
        ...p
      }
    });
    const wrappedAdoptedStyleSheetEmit = (a2) => wrappedEmit({
      type: EventType.IncrementalSnapshot,
      data: {
        source: IncrementalSource.AdoptedStyleSheet,
        ...a2
      }
    });
    const stylesheetManager = new StylesheetManager({
      mutationCb: wrappedMutationEmit,
      adoptedStyleSheetCb: wrappedAdoptedStyleSheetEmit
    });
    const iframeManager = new IframeManager({
      mirror,
      mutationCb: wrappedMutationEmit,
      stylesheetManager,
      recordCrossOriginIframes,
      wrappedEmit
    });
    for (const plugin3 of plugins || []) {
      if (plugin3.getMirror)
        plugin3.getMirror({
          nodeMirror: mirror,
          crossOriginIframeMirror: iframeManager.crossOriginIframeMirror,
          crossOriginIframeStyleMirror: iframeManager.crossOriginIframeStyleMirror
        });
    }
    const processedNodeManager = new ProcessedNodeManager();
    canvasManager = new CanvasManager({
      recordCanvas,
      mutationCb: wrappedCanvasMutationEmit,
      win: window,
      blockClass,
      blockSelector,
      mirror,
      sampling: sampling.canvas,
      dataURLOptions
    });
    const shadowDomManager = new ShadowDomManager({
      mutationCb: wrappedMutationEmit,
      scrollCb: wrappedScrollEmit,
      bypassOptions: {
        blockClass,
        blockSelector,
        maskTextClass,
        maskTextSelector,
        inlineStylesheet,
        maskInputOptions,
        dataURLOptions,
        maskTextFn,
        maskInputFn,
        recordCanvas,
        inlineImages,
        sampling,
        slimDOMOptions,
        iframeManager,
        stylesheetManager,
        canvasManager,
        keepIframeSrcFn,
        processedNodeManager
      },
      mirror
    });
    takeFullSnapshot$1 = (isCheckout = false) => {
      if (!recordDOM) {
        return;
      }
      wrappedEmit(
        {
          type: EventType.Meta,
          data: {
            href: window.location.href,
            width: getWindowWidth(),
            height: getWindowHeight()
          }
        },
        isCheckout
      );
      stylesheetManager.reset();
      shadowDomManager.init();
      mutationBuffers.forEach((buf) => buf.lock());
      const node2 = snapshot(document, {
        mirror,
        blockClass,
        blockSelector,
        maskTextClass,
        maskTextSelector,
        inlineStylesheet,
        maskAllInputs: maskInputOptions,
        maskTextFn,
        maskInputFn,
        slimDOM: slimDOMOptions,
        dataURLOptions,
        recordCanvas,
        inlineImages,
        onSerialize: (n2) => {
          if (isSerializedIframe(n2, mirror)) {
            iframeManager.addIframe(n2);
          }
          if (isSerializedStylesheet(n2, mirror)) {
            stylesheetManager.trackLinkElement(n2);
          }
          if (hasShadowRoot(n2)) {
            shadowDomManager.addShadowRoot(index.shadowRoot(n2), document);
          }
        },
        onIframeLoad: (iframe, childSn) => {
          iframeManager.attachIframe(iframe, childSn);
          shadowDomManager.observeAttachShadow(iframe);
        },
        onStylesheetLoad: (linkEl, childSn) => {
          stylesheetManager.attachLinkElement(linkEl, childSn);
        },
        keepIframeSrcFn
      });
      if (!node2) {
        return console.warn("Failed to snapshot the document");
      }
      wrappedEmit(
        {
          type: EventType.FullSnapshot,
          data: {
            node: node2,
            initialOffset: getWindowScroll(window)
          }
        },
        isCheckout
      );
      mutationBuffers.forEach((buf) => buf.unlock());
      if (document.adoptedStyleSheets && document.adoptedStyleSheets.length > 0)
        stylesheetManager.adoptStyleSheets(
          document.adoptedStyleSheets,
          mirror.getId(document)
        );
    };
    try {
      const handlers = [];
      const observe = (doc) => {
        var _a2;
        return callbackWrapper(initObservers)(
          {
            mutationCb: wrappedMutationEmit,
            mousemoveCb: (positions, source) => wrappedEmit({
              type: EventType.IncrementalSnapshot,
              data: {
                source,
                positions
              }
            }),
            mouseInteractionCb: (d) => wrappedEmit({
              type: EventType.IncrementalSnapshot,
              data: {
                source: IncrementalSource.MouseInteraction,
                ...d
              }
            }),
            scrollCb: wrappedScrollEmit,
            viewportResizeCb: (d) => wrappedEmit({
              type: EventType.IncrementalSnapshot,
              data: {
                source: IncrementalSource.ViewportResize,
                ...d
              }
            }),
            inputCb: (v2) => wrappedEmit({
              type: EventType.IncrementalSnapshot,
              data: {
                source: IncrementalSource.Input,
                ...v2
              }
            }),
            mediaInteractionCb: (p) => wrappedEmit({
              type: EventType.IncrementalSnapshot,
              data: {
                source: IncrementalSource.MediaInteraction,
                ...p
              }
            }),
            styleSheetRuleCb: (r2) => wrappedEmit({
              type: EventType.IncrementalSnapshot,
              data: {
                source: IncrementalSource.StyleSheetRule,
                ...r2
              }
            }),
            styleDeclarationCb: (r2) => wrappedEmit({
              type: EventType.IncrementalSnapshot,
              data: {
                source: IncrementalSource.StyleDeclaration,
                ...r2
              }
            }),
            canvasMutationCb: wrappedCanvasMutationEmit,
            fontCb: (p) => wrappedEmit({
              type: EventType.IncrementalSnapshot,
              data: {
                source: IncrementalSource.Font,
                ...p
              }
            }),
            selectionCb: (p) => {
              wrappedEmit({
                type: EventType.IncrementalSnapshot,
                data: {
                  source: IncrementalSource.Selection,
                  ...p
                }
              });
            },
            customElementCb: (c2) => {
              wrappedEmit({
                type: EventType.IncrementalSnapshot,
                data: {
                  source: IncrementalSource.CustomElement,
                  ...c2
                }
              });
            },
            blockClass,
            ignoreClass,
            ignoreSelector,
            maskTextClass,
            maskTextSelector,
            maskInputOptions,
            inlineStylesheet,
            sampling,
            recordDOM,
            recordCanvas,
            inlineImages,
            userTriggeredOnInput,
            collectFonts,
            doc,
            maskInputFn,
            maskTextFn,
            keepIframeSrcFn,
            blockSelector,
            slimDOMOptions,
            dataURLOptions,
            mirror,
            iframeManager,
            stylesheetManager,
            shadowDomManager,
            processedNodeManager,
            canvasManager,
            ignoreCSSAttributes,
            plugins: ((_a2 = plugins == null ? void 0 : plugins.filter((p) => p.observer)) == null ? void 0 : _a2.map((p) => ({
              observer: p.observer,
              options: p.options,
              callback: (payload) => wrappedEmit({
                type: EventType.Plugin,
                data: {
                  plugin: p.name,
                  payload
                }
              })
            }))) || []
          },
          hooks
        );
      };
      iframeManager.addLoadListener((iframeEl) => {
        try {
          handlers.push(observe(iframeEl.contentDocument));
        } catch (error) {
          console.warn(error);
        }
      });
      const init2 = () => {
        takeFullSnapshot$1();
        handlers.push(observe(document));
        recording = true;
      };
      if (["interactive", "complete"].includes(document.readyState)) {
        init2();
      } else {
        handlers.push(
          on("DOMContentLoaded", () => {
            wrappedEmit({
              type: EventType.DomContentLoaded,
              data: {}
            });
            if (recordAfter === "DOMContentLoaded") init2();
          })
        );
        handlers.push(
          on(
            "load",
            () => {
              wrappedEmit({
                type: EventType.Load,
                data: {}
              });
              if (recordAfter === "load") init2();
            },
            window
          )
        );
      }
      return () => {
        handlers.forEach((handler) => {
          try {
            handler();
          } catch (error) {
            const msg = String(error).toLowerCase();
            if (!msg.includes("cross-origin")) {
              console.warn(error);
            }
          }
        });
        processedNodeManager.destroy();
        recording = false;
        unregisterErrorHandler();
      };
    } catch (error) {
      console.warn(error);
    }
  }
  record.addCustomEvent = (tag, payload) => {
    if (!recording) {
      throw new Error("please add custom event after start recording");
    }
    wrappedEmit({
      type: EventType.Custom,
      data: {
        tag,
        payload
      }
    });
  };
  record.freezePage = () => {
    mutationBuffers.forEach((buf) => buf.freeze());
  };
  record.takeFullSnapshot = (isCheckout) => {
    if (!recording) {
      throw new Error("please take full snapshot after start recording");
    }
    takeFullSnapshot$1(isCheckout);
  };
  record.mirror = mirror;
  var n;
  !(function(t2) {
    t2[t2.NotStarted = 0] = "NotStarted", t2[t2.Running = 1] = "Running", t2[t2.Stopped = 2] = "Stopped";
  })(n || (n = {}));
  var SKIP_TIME_INTERVAL = 5 * 1e3;
  var { addCustomEvent } = record;
  var { freezePage } = record;
  var { takeFullSnapshot } = record;

  // ../../../node_modules/.pnpm/@rrweb+rrweb-plugin-console-record@2.0.0-alpha.20_@rrweb+utils@2.0.0-alpha.20_rrweb@2.0.0-alpha.20/node_modules/@rrweb/rrweb-plugin-console-record/dist/rrweb-plugin-console-record.js
  var __defProp3 = Object.defineProperty;
  var __defNormalProp3 = (obj, key, value) => key in obj ? __defProp3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
  var __publicField3 = (obj, key, value) => __defNormalProp3(obj, typeof key !== "symbol" ? key + "" : key, value);
  function patch2(source, name, replacement) {
    try {
      if (!(name in source)) {
        return () => {
        };
      }
      const original = source[name];
      const wrapped = replacement(original);
      if (typeof wrapped === "function") {
        wrapped.prototype = wrapped.prototype || {};
        Object.defineProperties(wrapped, {
          __rrweb_original__: {
            enumerable: false,
            value: original
          }
        });
      }
      source[name] = wrapped;
      return () => {
        source[name] = original;
      };
    } catch {
      return () => {
      };
    }
  }
  var StackFrame = class {
    constructor(obj) {
      __publicField3(this, "fileName");
      __publicField3(this, "functionName");
      __publicField3(this, "lineNumber");
      __publicField3(this, "columnNumber");
      this.fileName = obj.fileName || "";
      this.functionName = obj.functionName || "";
      this.lineNumber = obj.lineNumber;
      this.columnNumber = obj.columnNumber;
    }
    toString() {
      const lineNumber = this.lineNumber || "";
      const columnNumber = this.columnNumber || "";
      if (this.functionName)
        return `${this.functionName} (${this.fileName}:${lineNumber}:${columnNumber})`;
      return `${this.fileName}:${lineNumber}:${columnNumber}`;
    }
  };
  var FIREFOX_SAFARI_STACK_REGEXP = /(^|@)\S+:\d+/;
  var CHROME_IE_STACK_REGEXP = /^\s*at .*(\S+:\d+|\(native\))/m;
  var SAFARI_NATIVE_CODE_REGEXP = /^(eval@)?(\[native code])?$/;
  var ErrorStackParser = {
    /**
     * Given an Error object, extract the most information from it.
     */
    parse: function(error) {
      if (!error) {
        return [];
      }
      if (
        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
        // @ts-ignore
        typeof error.stacktrace !== "undefined" || // eslint-disable-next-line @typescript-eslint/ban-ts-comment
        // @ts-ignore
        typeof error["opera#sourceloc"] !== "undefined"
      ) {
        return this.parseOpera(
          error
        );
      } else if (error.stack && error.stack.match(CHROME_IE_STACK_REGEXP)) {
        return this.parseV8OrIE(error);
      } else if (error.stack) {
        return this.parseFFOrSafari(error);
      } else {
        console.warn(
          "[console-record-plugin]: Failed to parse error object:",
          error
        );
        return [];
      }
    },
    // Separate line and column numbers from a string of the form: (URI:Line:Column)
    extractLocation: function(urlLike) {
      if (urlLike.indexOf(":") === -1) {
        return [urlLike];
      }
      const regExp = /(.+?)(?::(\d+))?(?::(\d+))?$/;
      const parts = regExp.exec(urlLike.replace(/[()]/g, ""));
      if (!parts) throw new Error(`Cannot parse given url: ${urlLike}`);
      return [parts[1], parts[2] || void 0, parts[3] || void 0];
    },
    parseV8OrIE: function(error) {
      const filtered = error.stack.split("\n").filter(function(line) {
        return !!line.match(CHROME_IE_STACK_REGEXP);
      }, this);
      return filtered.map(function(line) {
        if (line.indexOf("(eval ") > -1) {
          line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(\),.*$)/g, "");
        }
        let sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(");
        const location = sanitizedLine.match(/ (\((.+):(\d+):(\d+)\)$)/);
        sanitizedLine = location ? sanitizedLine.replace(location[0], "") : sanitizedLine;
        const tokens = sanitizedLine.split(/\s+/).slice(1);
        const locationParts = this.extractLocation(
          location ? location[1] : tokens.pop()
        );
        const functionName = tokens.join(" ") || void 0;
        const fileName = ["eval", "<anonymous>"].indexOf(locationParts[0]) > -1 ? void 0 : locationParts[0];
        return new StackFrame({
          functionName,
          fileName,
          lineNumber: locationParts[1],
          columnNumber: locationParts[2]
        });
      }, this);
    },
    parseFFOrSafari: function(error) {
      const filtered = error.stack.split("\n").filter(function(line) {
        return !line.match(SAFARI_NATIVE_CODE_REGEXP);
      }, this);
      return filtered.map(function(line) {
        if (line.indexOf(" > eval") > -1) {
          line = line.replace(
            / line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g,
            ":$1"
          );
        }
        if (line.indexOf("@") === -1 && line.indexOf(":") === -1) {
          return new StackFrame({
            functionName: line
          });
        } else {
          const functionNameRegex = /((.*".+"[^@]*)?[^@]*)(?:@)/;
          const matches = line.match(functionNameRegex);
          const functionName = matches && matches[1] ? matches[1] : void 0;
          const locationParts = this.extractLocation(
            line.replace(functionNameRegex, "")
          );
          return new StackFrame({
            functionName,
            fileName: locationParts[0],
            lineNumber: locationParts[1],
            columnNumber: locationParts[2]
          });
        }
      }, this);
    },
    parseOpera: function(e) {
      if (!e.stacktrace || e.message.indexOf("\n") > -1 && e.message.split("\n").length > e.stacktrace.split("\n").length) {
        return this.parseOpera9(e);
      } else if (!e.stack) {
        return this.parseOpera10(e);
      } else {
        return this.parseOpera11(e);
      }
    },
    parseOpera9: function(e) {
      const lineRE = /Line (\d+).*script (?:in )?(\S+)/i;
      const lines = e.message.split("\n");
      const result2 = [];
      for (let i = 2, len = lines.length; i < len; i += 2) {
        const match = lineRE.exec(lines[i]);
        if (match) {
          result2.push(
            new StackFrame({
              fileName: match[2],
              lineNumber: parseFloat(match[1])
            })
          );
        }
      }
      return result2;
    },
    parseOpera10: function(e) {
      const lineRE = /Line (\d+).*script (?:in )?(\S+)(?:: In function (\S+))?$/i;
      const lines = e.stacktrace.split("\n");
      const result2 = [];
      for (let i = 0, len = lines.length; i < len; i += 2) {
        const match = lineRE.exec(lines[i]);
        if (match) {
          result2.push(
            new StackFrame({
              functionName: match[3] || void 0,
              fileName: match[2],
              lineNumber: parseFloat(match[1])
            })
          );
        }
      }
      return result2;
    },
    // Opera 10.65+ Error.stack very similar to FF/Safari
    parseOpera11: function(error) {
      const filtered = error.stack.split("\n").filter(function(line) {
        return !!line.match(FIREFOX_SAFARI_STACK_REGEXP) && !line.match(/^Error created at/);
      }, this);
      return filtered.map(function(line) {
        const tokens = line.split("@");
        const locationParts = this.extractLocation(tokens.pop());
        const functionCall = tokens.shift() || "";
        const functionName = functionCall.replace(/<anonymous function(: (\w+))?>/, "$2").replace(/\([^)]*\)/g, "") || void 0;
        return new StackFrame({
          functionName,
          fileName: locationParts[0],
          lineNumber: locationParts[1],
          columnNumber: locationParts[2]
        });
      }, this);
    }
  };
  function pathToSelector(node2) {
    if (!node2 || !node2.outerHTML) {
      return "";
    }
    let path = "";
    while (node2.parentElement) {
      let name = node2.localName;
      if (!name) {
        break;
      }
      name = name.toLowerCase();
      const parent = node2.parentElement;
      const domSiblings = [];
      if (parent.children && parent.children.length > 0) {
        for (let i = 0; i < parent.children.length; i++) {
          const sibling = parent.children[i];
          if (sibling.localName && sibling.localName.toLowerCase) {
            if (sibling.localName.toLowerCase() === name) {
              domSiblings.push(sibling);
            }
          }
        }
      }
      if (domSiblings.length > 1) {
        name += `:eq(${domSiblings.indexOf(node2)})`;
      }
      path = name + (path ? ">" + path : "");
      node2 = parent;
    }
    return path;
  }
  function isObject(obj) {
    return Object.prototype.toString.call(obj) === "[object Object]";
  }
  function isObjTooDeep(obj, limit) {
    if (limit === 0) {
      return true;
    }
    const keys = Object.keys(obj);
    for (const key of keys) {
      if (isObject(obj[key]) && isObjTooDeep(obj[key], limit - 1)) {
        return true;
      }
    }
    return false;
  }
  function stringify2(obj, stringifyOptions) {
    const options = {
      numOfKeysLimit: 50,
      depthOfLimit: 4
    };
    Object.assign(options, stringifyOptions);
    const stack = [];
    const keys = [];
    return JSON.stringify(
      obj,
      function(key, value) {
        if (stack.length > 0) {
          const thisPos = stack.indexOf(this);
          ~thisPos ? stack.splice(thisPos + 1) : stack.push(this);
          ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key);
          if (~stack.indexOf(value)) {
            if (stack[0] === value) {
              value = "[Circular ~]";
            } else {
              value = "[Circular ~." + keys.slice(0, stack.indexOf(value)).join(".") + "]";
            }
          }
        } else {
          stack.push(value);
        }
        if (value === null) return value;
        if (value === void 0) return "undefined";
        if (shouldIgnore(value)) {
          return toString(value);
        }
        if (typeof value === "bigint") {
          return value.toString() + "n";
        }
        if (value instanceof Event) {
          const eventResult = {};
          for (const eventKey in value) {
            const eventValue = value[eventKey];
            if (Array.isArray(eventValue)) {
              eventResult[eventKey] = pathToSelector(
                eventValue.length ? eventValue[0] : null
              );
            } else {
              eventResult[eventKey] = eventValue;
            }
          }
          return eventResult;
        } else if (value instanceof Node) {
          if (value instanceof HTMLElement) {
            return value ? value.outerHTML : "";
          }
          return value.nodeName;
        } else if (value instanceof Error) {
          return value.stack ? value.stack + "\nEnd of stack for Error object" : value.name + ": " + value.message;
        }
        return value;
      }
    );
    function shouldIgnore(_obj) {
      if (isObject(_obj) && Object.keys(_obj).length > options.numOfKeysLimit) {
        return true;
      }
      if (typeof _obj === "function") {
        return true;
      }
      if (isObject(_obj) && isObjTooDeep(_obj, options.depthOfLimit)) {
        return true;
      }
      return false;
    }
    function toString(_obj) {
      let str = _obj.toString();
      if (options.stringLengthLimit && str.length > options.stringLengthLimit) {
        str = `${str.slice(0, options.stringLengthLimit)}...`;
      }
      return str;
    }
  }
  var defaultLogOptions = {
    level: [
      "assert",
      "clear",
      "count",
      "countReset",
      "debug",
      "dir",
      "dirxml",
      "error",
      "group",
      "groupCollapsed",
      "groupEnd",
      "info",
      "log",
      "table",
      "time",
      "timeEnd",
      "timeLog",
      "trace",
      "warn"
    ],
    lengthThreshold: 1e3,
    logger: "console"
  };
  function initLogObserver(cb, win, options) {
    const logOptions = options ? Object.assign({}, defaultLogOptions, options) : defaultLogOptions;
    const loggerType = logOptions.logger;
    if (!loggerType) {
      return () => {
      };
    }
    let logger;
    if (typeof loggerType === "string") {
      logger = win[loggerType];
    } else {
      logger = loggerType;
    }
    let logCount = 0;
    let inStack = false;
    const cancelHandlers = [];
    if (logOptions.level.includes("error")) {
      const errorHandler2 = (event) => {
        const message = event.message, error = event.error;
        const trace = ErrorStackParser.parse(error).map(
          (stackFrame) => stackFrame.toString()
        );
        const payload = [stringify2(message, logOptions.stringifyOptions)];
        cb({
          level: "error",
          trace,
          payload
        });
      };
      win.addEventListener("error", errorHandler2);
      cancelHandlers.push(() => {
        win.removeEventListener("error", errorHandler2);
      });
      const unhandledrejectionHandler = (event) => {
        let error;
        let payload;
        if (event.reason instanceof Error) {
          error = event.reason;
          payload = [
            stringify2(
              `Uncaught (in promise) ${error.name}: ${error.message}`,
              logOptions.stringifyOptions
            )
          ];
        } else {
          error = new Error();
          payload = [
            stringify2("Uncaught (in promise)", logOptions.stringifyOptions),
            stringify2(event.reason, logOptions.stringifyOptions)
          ];
        }
        const trace = ErrorStackParser.parse(error).map(
          (stackFrame) => stackFrame.toString()
        );
        cb({
          level: "error",
          trace,
          payload
        });
      };
      win.addEventListener("unhandledrejection", unhandledrejectionHandler);
      cancelHandlers.push(() => {
        win.removeEventListener("unhandledrejection", unhandledrejectionHandler);
      });
    }
    for (const levelType of logOptions.level) {
      cancelHandlers.push(replace(logger, levelType));
    }
    return () => {
      cancelHandlers.forEach((h) => h());
    };
    function replace(_logger, level) {
      if (!_logger[level]) {
        return () => {
        };
      }
      return patch2(
        _logger,
        level,
        (original) => {
          return (...args) => {
            original.apply(this, args);
            if (level === "assert" && !!args[0]) {
              return;
            }
            if (inStack) {
              return;
            }
            inStack = true;
            try {
              const trace = ErrorStackParser.parse(new Error()).map((stackFrame) => stackFrame.toString()).splice(1);
              const argsForPayload = level === "assert" ? args.slice(1) : args;
              const payload = argsForPayload.map(
                (s) => stringify2(s, logOptions.stringifyOptions)
              );
              logCount++;
              if (logCount < logOptions.lengthThreshold) {
                cb({
                  level,
                  trace,
                  payload
                });
              } else if (logCount === logOptions.lengthThreshold) {
                cb({
                  level: "warn",
                  trace: [],
                  payload: [
                    stringify2("The number of log records reached the threshold.")
                  ]
                });
              }
            } catch (error) {
              original("rrweb logger error:", error, ...args);
            } finally {
              inStack = false;
            }
          };
        }
      );
    }
  }
  var PLUGIN_NAME = "rrweb/console@1";
  var getRecordConsolePlugin = (options) => ({
    name: PLUGIN_NAME,
    observer: initLogObserver,
    options
  });

  // ../../../node_modules/.pnpm/@rrweb+types@2.0.0-alpha.20/node_modules/@rrweb/types/dist/types.js
  var NodeType2 = /* @__PURE__ */ ((NodeType22) => {
    NodeType22[NodeType22["Document"] = 0] = "Document";
    NodeType22[NodeType22["DocumentType"] = 1] = "DocumentType";
    NodeType22[NodeType22["Element"] = 2] = "Element";
    NodeType22[NodeType22["Text"] = 3] = "Text";
    NodeType22[NodeType22["CDATA"] = 4] = "CDATA";
    NodeType22[NodeType22["Comment"] = 5] = "Comment";
    return NodeType22;
  })(NodeType2 || {});

  // src/builder-bridge/plugins/network-record/index.ts
  var PLUGIN_NAME2 = "base44/network@1";
  var DEFAULT_OPTIONS = {
    recordFetch: true,
    recordXHR: true,
    maxUrlLength: 500,
    maxResponseBodyLength: 2e3,
    captureBody: "errors",
    ignoreUrls: []
  };
  var METHODS_WITH_BODY = ["POST", "PUT", "PATCH"];
  function shouldCaptureBody(status, captureBody) {
    if (captureBody === "none") return false;
    if (captureBody === "all") return true;
    return status === null || status >= 400;
  }
  function methodHasBody(method) {
    return METHODS_WITH_BODY.includes(method.toUpperCase());
  }
  function truncateString(str, maxLength) {
    if (str.length <= maxLength) return str;
    return str.slice(0, maxLength - 3) + "...";
  }
  function shouldIgnoreUrl(url, ignorePatterns) {
    return ignorePatterns.some((pattern) => {
      if (typeof pattern === "string") {
        return url.includes(pattern);
      }
      return pattern.test(url);
    });
  }
  async function tryReadResponseBody(response, maxLength) {
    try {
      const contentType = response.headers.get("content-type") || "";
      if (contentType.includes("video/") || contentType.includes("audio/") || contentType.includes("image/") || contentType.includes("application/octet-stream")) {
        return `[Binary content: ${contentType}]`;
      }
      const clone = response.clone();
      const bodyPromise = clone.text();
      let timeoutId;
      const timeoutPromise = new Promise((_, reject) => {
        timeoutId = setTimeout(() => reject(new Error("Timeout")), 500);
      });
      try {
        const body = await Promise.race([bodyPromise, timeoutPromise]);
        return truncateString(body, maxLength);
      } finally {
        clearTimeout(timeoutId);
      }
    } catch {
      return void 0;
    }
  }
  function formatCommonBodyTypes(body, maxLength) {
    if (typeof body === "string") {
      return truncateString(body, maxLength);
    }
    if (body instanceof URLSearchParams) {
      return truncateString(body.toString(), maxLength);
    }
    if (body instanceof FormData) {
      const parts = [];
      body.forEach((value, key) => {
        if (typeof value === "string") {
          parts.push(`${key}=${value}`);
        } else {
          parts.push(`${key}=[File: ${value.name}]`);
        }
      });
      return truncateString(parts.join("&"), maxLength);
    }
    if (body instanceof Blob) {
      return `[Blob: ${body.size} bytes, ${body.type || "unknown type"}]`;
    }
    if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) {
      return `[Binary: ${body.byteLength} bytes]`;
    }
    return void 0;
  }
  function tryReadRequestBody(input2, init2, maxLength) {
    try {
      const body = init2?.body;
      if (!body) {
        if (input2 instanceof Request && input2.body) {
          return "[Request body]";
        }
        return void 0;
      }
      const formatted = formatCommonBodyTypes(body, maxLength);
      if (formatted !== void 0) {
        return formatted;
      }
      return "[Unknown body type]";
    } catch {
      return void 0;
    }
  }
  function tryReadXHRRequestBody(body, maxLength) {
    try {
      if (!body) return void 0;
      const formatted = formatCommonBodyTypes(body, maxLength);
      if (formatted !== void 0) {
        return formatted;
      }
      if (body instanceof Document) {
        return truncateString(body.documentElement?.outerHTML || "[Document]", maxLength);
      }
      return "[Unknown body type]";
    } catch {
      return void 0;
    }
  }
  function initFetchObserver(cb, win, options) {
    if (!options.recordFetch) {
      return () => {
      };
    }
    const originalFetch = win.fetch.bind(win);
    win.fetch = async function(input2, init2) {
      const startTime = Date.now();
      const url = typeof input2 === "string" ? input2 : input2 instanceof URL ? input2.href : input2.url;
      const method = (init2?.method || (input2 instanceof Request ? input2.method : "GET")).toUpperCase();
      if (shouldIgnoreUrl(url, options.ignoreUrls)) {
        return originalFetch(input2, init2);
      }
      const capturedRequestBody = methodHasBody(method) ? tryReadRequestBody(input2, init2, options.maxResponseBodyLength) : void 0;
      let response;
      try {
        response = await originalFetch(input2, init2);
        const request = {
          method,
          url: truncateString(url, options.maxUrlLength),
          status: response.status,
          duration: Date.now() - startTime,
          timestamp: startTime,
          initiatorType: "fetch"
        };
        if (shouldCaptureBody(response.status, options.captureBody)) {
          if (capturedRequestBody) {
            request.requestBody = capturedRequestBody;
          }
          request.responseBody = await tryReadResponseBody(response, options.maxResponseBodyLength);
        }
        cb(request);
        return response;
      } catch (error) {
        const request = {
          method,
          url: truncateString(url, options.maxUrlLength),
          status: null,
          duration: Date.now() - startTime,
          timestamp: startTime,
          initiatorType: "fetch",
          error: error instanceof Error ? error.message : String(error)
        };
        if (shouldCaptureBody(null, options.captureBody) && capturedRequestBody) {
          request.requestBody = capturedRequestBody;
        }
        cb(request);
        throw error;
      }
    };
    return () => {
      win.fetch = originalFetch;
    };
  }
  function initXHRObserver(cb, win, options) {
    if (!options.recordXHR) {
      return () => {
      };
    }
    const XHR = win.XMLHttpRequest;
    const originalOpen = XHR.prototype.open;
    const originalSend = XHR.prototype.send;
    XHR.prototype.open = function(method, url, async = true, username, password) {
      this.__networkRecord = {
        method: method.toUpperCase(),
        url: typeof url === "string" ? url : url.href,
        startTime: 0
      };
      return originalOpen.call(this, method, url, async, username, password);
    };
    XHR.prototype.send = function(body) {
      const xhr = this;
      const recordData = xhr.__networkRecord;
      if (!recordData) {
        return originalSend.call(this, body);
      }
      if (shouldIgnoreUrl(recordData.url, options.ignoreUrls)) {
        return originalSend.call(this, body);
      }
      recordData.startTime = Date.now();
      let capturedRequestBody;
      if (methodHasBody(recordData.method) && body) {
        capturedRequestBody = tryReadXHRRequestBody(body, options.maxResponseBodyLength);
      }
      const removeAllListeners = () => {
        xhr.removeEventListener("load", handleComplete);
        xhr.removeEventListener("error", handleError);
        xhr.removeEventListener("abort", handleAbort);
        xhr.removeEventListener("timeout", handleTimeout);
      };
      const handleErrorEvent = (errorMessage) => {
        const request = {
          method: recordData.method,
          url: truncateString(recordData.url, options.maxUrlLength),
          status: null,
          duration: Date.now() - recordData.startTime,
          timestamp: recordData.startTime,
          initiatorType: "xmlhttprequest",
          error: errorMessage
        };
        if (shouldCaptureBody(null, options.captureBody) && capturedRequestBody) {
          request.requestBody = capturedRequestBody;
        }
        cb(request);
        removeAllListeners();
      };
      const handleComplete = () => {
        const status = xhr.status ?? null;
        const request = {
          method: recordData.method,
          url: truncateString(recordData.url, options.maxUrlLength),
          status,
          duration: Date.now() - recordData.startTime,
          timestamp: recordData.startTime,
          initiatorType: "xmlhttprequest"
        };
        if (shouldCaptureBody(status, options.captureBody)) {
          if (capturedRequestBody) {
            request.requestBody = capturedRequestBody;
          }
          try {
            let responseBody;
            if (typeof xhr.response === "string") {
              responseBody = xhr.response;
            } else if (xhr.response != null && typeof xhr.response === "object") {
              responseBody = JSON.stringify(xhr.response);
            } else if (xhr.responseType === "" || xhr.responseType === "text") {
              responseBody = xhr.responseText;
            }
            if (responseBody) {
              request.responseBody = truncateString(
                responseBody,
                options.maxResponseBodyLength
              );
            }
          } catch {
          }
        }
        cb(request);
        removeAllListeners();
      };
      const handleError = () => handleErrorEvent("Network error");
      const handleAbort = () => handleErrorEvent("Request aborted");
      const handleTimeout = () => handleErrorEvent("Request timeout");
      xhr.addEventListener("load", handleComplete);
      xhr.addEventListener("error", handleError);
      xhr.addEventListener("abort", handleAbort);
      xhr.addEventListener("timeout", handleTimeout);
      return originalSend.call(this, body);
    };
    return () => {
      XHR.prototype.open = originalOpen;
      XHR.prototype.send = originalSend;
    };
  }
  function initNetworkObserver(cb, win, options) {
    const cleanupFetch = initFetchObserver(cb, win, options);
    const cleanupXHR = initXHRObserver(cb, win, options);
    return () => {
      cleanupFetch();
      cleanupXHR();
    };
  }
  function getRecordNetworkPlugin(options) {
    const resolvedOptions = { ...DEFAULT_OPTIONS, ...options };
    return {
      name: PLUGIN_NAME2,
      observer: (cb, win) => {
        const networkCallback = (request) => {
          cb({
            plugin: PLUGIN_NAME2,
            payload: request
          });
        };
        return initNetworkObserver(networkCallback, win, resolvedOptions);
      },
      options: resolvedOptions
    };
  }

  // src/builder-bridge/native-failures.ts
  var BUFFER_VERSION = 1;
  var MAX_ENTRIES = 100;
  var MAX_MESSAGE_LENGTH = 5e3;
  function getStringProperty(value, property) {
    if (typeof value !== "object" || value === null) return "";
    const candidate = value[property];
    return typeof candidate === "string" ? candidate : "";
  }
  function getBuffer() {
    if (typeof window === "undefined") return null;
    const existing = window.__base44_preview_native_failures;
    if (existing?.version === BUFFER_VERSION && Array.isArray(existing.entries) && typeof existing.listenersInstalled === "boolean") {
      return existing;
    }
    const buffer = {
      version: BUFFER_VERSION,
      entries: [],
      listenersInstalled: false
    };
    window.__base44_preview_native_failures = buffer;
    return buffer;
  }
  function appendFailure(buffer, message) {
    const trimmedMessage = message.slice(0, MAX_MESSAGE_LENGTH);
    if (!trimmedMessage) return;
    for (let index2 = buffer.entries.length - 1; index2 >= 0; index2 -= 1) {
      const existing = buffer.entries[index2];
      if (existing?.level === "error" && existing.message === trimmedMessage) {
        buffer.entries.splice(index2, 1);
      }
    }
    buffer.entries.push({
      level: "error",
      message: trimmedMessage,
      timestamp: Date.now()
    });
    if (buffer.entries.length > MAX_ENTRIES) {
      buffer.entries.splice(0, buffer.entries.length - MAX_ENTRIES);
    }
  }
  function formatErrorEvent(event) {
    const target = event.target;
    const tagName = getStringProperty(target, "tagName").toLowerCase();
    const targetType = tagName || "window";
    const isModule = targetType === "script" && getStringProperty(target, "type").toLowerCase() === "module";
    const resourceType = isModule ? "module" : targetType;
    const url = getStringProperty(target, "src") || getStringProperty(target, "href") || event.filename || "";
    const detail = event.message || getStringProperty(event.error, "message");
    const prefix = targetType === "window" ? "Native browser error" : `Failed to load ${resourceType}`;
    return `${prefix}${url ? ` ${url}` : ""}${detail ? `: ${detail}` : ""}`;
  }
  function formatRejectionReason(reason) {
    if (typeof reason === "string") return reason;
    const message = getStringProperty(reason, "message");
    if (message) return message;
    try {
      return JSON.stringify(reason) || String(reason);
    } catch {
      return String(reason);
    }
  }
  function formatUnhandledRejection(event) {
    return `Unhandled promise rejection: ${formatRejectionReason(event.reason)}`;
  }
  function formatCspViolation(event) {
    const blockedUri = event.blockedURI || "resource";
    const directive = event.violatedDirective;
    return `Content Security Policy blocked ${blockedUri}${directive ? ` (${directive})` : ""}`;
  }
  function installNativeFailureListeners() {
    const buffer = getBuffer();
    if (!buffer || buffer.listenersInstalled) return;
    window.addEventListener("error", (event) => {
      appendFailure(buffer, formatErrorEvent(event));
    }, true);
    window.addEventListener("unhandledrejection", (event) => {
      appendFailure(buffer, formatUnhandledRejection(event));
    });
    window.addEventListener("securitypolicyviolation", (event) => {
      appendFailure(buffer, formatCspViolation(event));
    });
    buffer.listenersInstalled = true;
  }
  function getNativeFailureEntries() {
    const buffer = getBuffer();
    if (!buffer) return [];
    return buffer.entries.filter((entry) => entry?.level === "error" && typeof entry.message === "string" && typeof entry.timestamp === "number");
  }
  installNativeFailureListeners();

  // src/builder-bridge/recorder.ts
  function isFullSnapshotEvent(event) {
    return event.type === EventType.FullSnapshot;
  }
  function isMutationEvent(event) {
    return event.type === EventType.IncrementalSnapshot && "data" in event && event.data.source === IncrementalSource.Mutation;
  }
  function isElementNode(node2) {
    return "type" in node2 && node2.type === NodeType2.Element;
  }
  function isTextNode(node2) {
    return "type" in node2 && node2.type === NodeType2.Text;
  }
  var MAX_CONSOLE_ENTRIES = 100;
  var MAX_USER_ACTIONS = 50;
  var MAX_NETWORK_REQUESTS = 50;
  var MAX_STRING_LENGTH = 5e3;
  var MAX_INPUT_LENGTH = 100;
  var MAX_EVENTS_BUFFER = 1e3;
  var TRIM_TO_EVENTS = 500;
  var CONSOLE_NOISE_PATTERNS = [
    "[vite]",
    "React Router Future Flag Warning",
    "[HMR]",
    "[Fast Refresh]"
  ];
  var recordingState = {
    isRecording: false,
    sessionId: "",
    events: [],
    stopFn: null
  };
  function generateSessionId() {
    return `session-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
  }
  function startRecording(onNewEvents) {
    if (recordingState.isRecording) {
      return;
    }
    if (typeof window === "undefined") {
      console.warn("[Recorder] Recording only available in browser");
      return;
    }
    installNativeFailureListeners();
    recordingState.isRecording = true;
    recordingState.sessionId = generateSessionId();
    recordingState.events = [];
    const stopFn = record({
      emit: (event) => {
        if (!isMutationEvent(event)) {
          recordingState.events.push(event);
          if (recordingState.events.length > MAX_EVENTS_BUFFER) {
            recordingState.events = recordingState.events.slice(
              -TRIM_TO_EVENTS
            );
          }
        }
        onNewEvents?.(event);
      },
      plugins: [
        getRecordConsolePlugin({
          level: ["log", "warn", "error", "info", "debug"],
          lengthThreshold: 1e4,
          stringifyOptions: {
            stringLengthLimit: MAX_STRING_LENGTH,
            numOfKeysLimit: 100,
            depthOfLimit: 5
          }
        }),
        getRecordNetworkPlugin({
          // Capture all request/response bodies for testing
          captureBody: "all",
          // Ignore common telemetry/analytics URLs
          ignoreUrls: [
            "/socket.io",
            "analytics",
            "telemetry",
            "sentry",
            "datadog",
            "mixpanel",
            "amplitude"
          ]
        })
      ]
    });
    recordingState.stopFn = stopFn ?? null;
  }
  function extractDebugSnapshot() {
    return {
      sessionId: recordingState.sessionId,
      timestamp: Date.now(),
      url: window.location.href,
      console: extractConsoleEntries(recordingState.events, getNativeFailureEntries()),
      userActions: extractUserActions(recordingState.events),
      network: extractNetworkRequests(recordingState.events)
    };
  }
  function extractConsoleEntries(events, nativeFailures = []) {
    const entries = [];
    for (const event of events) {
      if (event.type === 6 && event.data?.plugin === "rrweb/console@1") {
        const payload = event.data.payload;
        if (payload && payload.level && payload.payload) {
          const message = stringifyConsolePayload(payload.payload);
          if (CONSOLE_NOISE_PATTERNS.some((pattern) => message.includes(pattern))) {
            continue;
          }
          entries.push({
            level: payload.level,
            message: truncateString2(message, MAX_STRING_LENGTH),
            timestamp: event.timestamp
          });
        }
      }
    }
    const retainedNativeFailures = dedupeNativeFailures(nativeFailures).sort((left, right) => left.timestamp - right.timestamp).slice(-MAX_CONSOLE_ENTRIES);
    const rrwebCapacity = MAX_CONSOLE_ENTRIES - retainedNativeFailures.length;
    const recentRRWebEntries = entries.slice(Math.max(0, entries.length - rrwebCapacity));
    return [...recentRRWebEntries, ...retainedNativeFailures].sort((left, right) => left.timestamp - right.timestamp);
  }
  function dedupeNativeFailures(nativeFailures) {
    const latestByKey = /* @__PURE__ */ new Map();
    for (const entry of nativeFailures) {
      latestByKey.set(`${entry.level}:${entry.message}`, entry);
    }
    return [...latestByKey.values()];
  }
  function extractNetworkRequests(events) {
    const requests = [];
    for (const event of events) {
      if (event.type === 6 && event.data?.plugin === PLUGIN_NAME2) {
        const payload = event.data.payload?.payload;
        if (payload) {
          if (!payload.url || !payload.timestamp) {
            continue;
          }
          requests.push(payload);
        }
      }
    }
    return requests.slice(-MAX_NETWORK_REQUESTS);
  }
  function extractUserActions(events) {
    const actions = [];
    const nodeMap = buildNodeMap(events);
    for (const event of events) {
      if (event.type !== 3 || !event.data) continue;
      const { source, type, id, text } = event.data;
      if (source === IncrementalSource.MouseInteraction && id !== void 0) {
        const actionType = getMouseInteractionType(type);
        if (actionType) {
          actions.push({
            type: actionType,
            target: nodeMap.get(id) || `element#${id}`,
            timestamp: event.timestamp
          });
        }
      }
      if (source === IncrementalSource.Input && id !== void 0) {
        actions.push({
          type: "input",
          target: nodeMap.get(id) || `input#${id}`,
          value: text ? truncateString2(text, MAX_INPUT_LENGTH) : void 0,
          timestamp: event.timestamp
        });
      }
    }
    return actions.slice(-MAX_USER_ACTIONS);
  }
  function getMouseInteractionType(type) {
    switch (type) {
      case MouseInteractions.Click:
        return "click";
      case MouseInteractions.DblClick:
        return "dblclick";
      default:
        return null;
    }
  }
  function buildNodeMap(events) {
    const nodeMap = /* @__PURE__ */ new Map();
    const fullSnapshot = events.find(isFullSnapshotEvent);
    if (!fullSnapshot) return nodeMap;
    const extractNodes = (node2) => {
      if (!node2 || typeof node2 !== "object") return;
      if (isElementNode(node2)) {
        const parts = [];
        const tagName = node2.tagName.toLowerCase();
        const attrs = node2.attributes || {};
        const sourceLocation = attrs["data-source-location"];
        if (typeof sourceLocation === "string") {
          parts.push(`[${sourceLocation}]`);
        }
        let tagPart = `<${tagName}`;
        const attrId = attrs.id;
        const attrClass = attrs.class;
        if (typeof attrId === "string") {
          tagPart += `#${attrId}`;
        } else if (typeof attrClass === "string") {
          const firstClass = attrClass.split(" ")[0];
          if (firstClass) tagPart += `.${firstClass}`;
        }
        tagPart += ">";
        parts.push(tagPart);
        for (const child of node2.childNodes) {
          if (isTextNode(child)) {
            const text = child.textContent.trim().slice(0, 30);
            if (text) {
              parts.push(`"${text}"`);
              break;
            }
          }
        }
        nodeMap.set(node2.id, parts.join(" "));
      }
      if ("childNodes" in node2) {
        for (const child of node2.childNodes) {
          extractNodes(child);
        }
      }
    };
    extractNodes(fullSnapshot.data.node);
    for (const event of events) {
      if (isMutationEvent(event)) {
        for (const add of event.data.adds) {
          extractNodes(add.node);
        }
      }
    }
    return nodeMap;
  }
  function stringifyConsolePayload(payload) {
    return payload.map((item) => {
      if (typeof item === "string") {
        return item;
      }
      try {
        return JSON.stringify(item);
      } catch {
        return String(item);
      }
    }).join(" ");
  }
  function truncateString2(str, maxLength) {
    if (str.length <= maxLength) return str;
    return str.slice(0, maxLength - 3) + "...";
  }

  // src/builder-bridge/page-not-found-tracker.ts
  var DD_SITE_TO_CDN_REGION = {
    "datadoghq.com": "us1",
    "datadoghq.eu": "eu1",
    "us3.datadoghq.com": "us3",
    "us5.datadoghq.com": "us5",
    "ap1.datadoghq.com": "ap1"
  };
  var NAVIGATION_CHECK_DELAY_MS = 150;
  var PAGE_NOT_FOUND_EVENT = "preview_page_not_found";
  function getCdnUrl(ddSite, bundle) {
    const region = DD_SITE_TO_CDN_REGION[ddSite] ?? "us1";
    return `https://www.datadoghq-browser-agent.com/${region}/v5/${bundle}`;
  }
  function is404Page() {
    const h1s = document.querySelectorAll("h1");
    for (const h1 of h1s) {
      if (h1.textContent?.trim() !== "404") continue;
      let container2 = h1.parentElement;
      for (let depth = 0; depth < 3 && container2; depth++) {
        const h2 = container2.querySelector("h2");
        if (h2?.textContent?.trim() === "Page Not Found") return true;
        container2 = container2.parentElement;
      }
    }
    return false;
  }
  function initPageNotFoundTracker(config) {
    const { appId, previewType, rumAppId, rumClientToken, ddSite, onPageNotFound } = config;
    if (!rumAppId || !rumClientToken) return;
    let rumReported = false;
    let logReported = false;
    let parentNotified = false;
    let rumLoaded = false;
    let logsLoaded = false;
    let rumLoadAttempts = 0;
    let currentPath = window.location.pathname;
    function report404() {
      const context = {
        app_id: appId,
        url_path: currentPath,
        preview_type: previewType
      };
      if (!parentNotified && onPageNotFound) {
        parentNotified = true;
        try {
          onPageNotFound(context);
        } catch {
        }
      }
      if (rumReported && logReported) return;
      if (!rumReported && window.DD_RUM?.addAction) {
        rumReported = true;
        try {
          window.DD_RUM.addAction(PAGE_NOT_FOUND_EVENT, context);
        } catch {
        }
      }
      if (!logReported && window.DD_LOGS?.logger) {
        logReported = true;
        try {
          window.DD_LOGS.logger.warn(PAGE_NOT_FOUND_EVENT, context);
        } catch {
        }
      }
    }
    function checkFor404() {
      if (is404Page()) {
        report404();
      }
    }
    function onNavigation() {
      const newPath = window.location.pathname;
      if (newPath !== currentPath) {
        currentPath = newPath;
        rumReported = false;
        logReported = false;
        parentNotified = false;
      }
      loadRUM();
      const pathAtScheduleTime = currentPath;
      setTimeout(() => {
        if (currentPath === pathAtScheduleTime) {
          checkFor404();
        }
      }, NAVIGATION_CHECK_DELAY_MS);
    }
    const observer = new MutationObserver(() => {
      checkFor404();
    });
    function startObserver() {
      if (document.body) {
        observer.observe(document.body, { childList: true, subtree: true });
        checkFor404();
      }
    }
    window.addEventListener("message", (msg) => {
      if (msg.data?.type === "CHECK_PAGE_NOT_FOUND") {
        parentNotified = false;
        checkFor404();
      }
    });
    window.addEventListener("popstate", onNavigation);
    const origPushState = history.pushState.bind(history);
    history.pushState = function(...args) {
      origPushState(...args);
      onNavigation();
    };
    const origReplaceState = history.replaceState.bind(history);
    history.replaceState = function(...args) {
      origReplaceState(...args);
      onNavigation();
    };
    const MAX_RUM_LOAD_ATTEMPTS = 3;
    function loadRUM() {
      if (rumLoaded) return;
      if (rumLoadAttempts >= MAX_RUM_LOAD_ATTEMPTS) return;
      rumLoaded = true;
      rumLoadAttempts++;
      const rumScript = document.createElement("script");
      rumScript.src = getCdnUrl(ddSite, "datadog-rum.js");
      rumScript.onload = () => {
        try {
          window.DD_RUM?.init({
            applicationId: rumAppId,
            clientToken: rumClientToken,
            site: ddSite,
            service: "base44-preview",
            sessionSampleRate: 100,
            sessionReplaySampleRate: 0,
            trackUserInteractions: false,
            trackResources: false,
            trackLongTasks: false,
            startSessionReplayRecordingManually: true
          });
        } catch {
        }
        checkFor404();
      };
      rumScript.onerror = () => {
        rumLoaded = false;
      };
      document.head.appendChild(rumScript);
      if (logsLoaded) return;
      logsLoaded = true;
      const logsScript = document.createElement("script");
      logsScript.src = getCdnUrl(ddSite, "datadog-logs.js");
      logsScript.onload = () => {
        try {
          window.DD_LOGS?.init({
            clientToken: rumClientToken,
            site: ddSite,
            service: "base44-preview",
            forwardErrorsToLogs: false,
            forwardConsoleLogs: [],
            sessionSampleRate: 100
          });
        } catch {
        }
        checkFor404();
      };
      document.head.appendChild(logsScript);
    }
    if (document.readyState === "loading") {
      document.addEventListener("DOMContentLoaded", () => {
        loadRUM();
        startObserver();
      });
    } else {
      loadRUM();
      startObserver();
    }
  }

  // src/builder-bridge/engagement-tracker.ts
  var BURST_GAP_MS = 500;
  function initEngagementTracker(send) {
    const lastEvent = {
      click: -Infinity,
      scroll: -Infinity,
      keypress: -Infinity
    };
    function emit(kind) {
      const now = Date.now();
      const isNewBurst = now - lastEvent[kind] > BURST_GAP_MS;
      lastEvent[kind] = now;
      if (isNewBurst) {
        send("PREVIEW_ENGAGEMENT", { kind });
      } else if (kind === "click" || kind === "keypress") {
        const rageKind = kind === "click" ? "rage_click" : "rage_keypress";
        send("PREVIEW_ENGAGEMENT", { kind: rageKind });
      }
    }
    document.addEventListener("click", () => emit("click"), { capture: true, passive: true });
    document.addEventListener("scroll", () => emit("scroll"), { capture: true, passive: true });
    document.addEventListener("keydown", () => emit("keypress"), { capture: true, passive: true });
  }

  // src/builder-bridge/keyboard-input-scroll.ts
  var EDITABLE = /^(INPUT|TEXTAREA|SELECT)$/;
  var SETTLE_MS = 150;
  var pendingReveal = 0;
  function focusedEditable() {
    const el = document.activeElement;
    if (!el) return null;
    return EDITABLE.test(el.tagName) || el.isContentEditable ? el : null;
  }
  function revealIfObscured() {
    const el = focusedEditable();
    if (!el) return;
    const rect = el.getBoundingClientRect();
    const viewportHeight = window.visualViewport?.height ?? window.innerHeight;
    if (rect.top >= 0 && rect.bottom <= viewportHeight) return;
    el.scrollIntoView({ block: "center" });
  }
  function scheduleReveal() {
    clearTimeout(pendingReveal);
    pendingReveal = window.setTimeout(revealIfObscured, SETTLE_MS);
  }
  function initKeyboardInputScroll() {
    if (!window.matchMedia("(pointer: coarse)").matches) return;
    document.addEventListener("focusin", (event) => {
      const node2 = event.target;
      if (node2 && (EDITABLE.test(node2.tagName) || node2.isContentEditable)) scheduleReveal();
    });
    const onResize = () => {
      if (focusedEditable()) scheduleReveal();
    };
    window.visualViewport?.addEventListener("resize", onResize);
    window.addEventListener("resize", onResize);
  }

  // src/builder-bridge/react-inspector/constants.ts
  var MAX_OBJECT_DEPTH = 4;
  var MAX_ARRAY_ITEMS = 25;
  var MAX_OBJECT_KEYS = 50;
  var MAX_STRING_LENGTH2 = 500;
  var MAX_COMPONENT_STACK_DEPTH = 12;
  var MAX_FULL_TREE_COMPONENTS = 100;
  var MAX_REACT_PAYLOAD_BYTES = 200 * 1024;
  var MAX_TARGET_QUERY_LENGTH = 500;
  var MAX_TARGET_SEARCH_FIBERS = 2e3;
  var REDACT_KEY_RE = /password|token|secret|authorization|cookie|api[_-]?key|access[_-]?token|refresh[_-]?token|auth[_-]?token|jwt/i;
  function warnOnce3(warnings, message) {
    if (!warnings.includes(message)) warnings.push(message);
  }

  // src/builder-bridge/react-inspector/fiber.ts
  function getFiber(element) {
    if (!element) return null;
    const key = Object.getOwnPropertyNames(element).find((k) => k.startsWith("__reactFiber$"));
    return key ? element[key] : null;
  }
  function getRenderFn(type) {
    if (!type) return null;
    if (typeof type === "function") return type;
    if (typeof type === "object") {
      const wrapped = type;
      if (wrapped.$$typeof) {
        if (typeof wrapped.render === "function") return wrapped.render;
        if (wrapped.type) return getRenderFn(wrapped.type);
      }
    }
    return null;
  }
  function isFunctionComponent(fiber) {
    const fn = getRenderFn(fiber?.type);
    return typeof fn === "function" && !fn.prototype?.isReactComponent;
  }
  function getComponentName(fiber) {
    const type = fiber.type;
    if (typeof type === "function") {
      return type.displayName || type.name || "Anonymous";
    }
    if (typeof type === "object" && type && "displayName" in type && typeof type.displayName === "string") {
      return type.displayName;
    }
    const fn = getRenderFn(type);
    return fn?.displayName || fn?.name || "Anonymous";
  }
  function getSourceLocationFromProps(props) {
    const value = props?.["data-source-location"];
    return typeof value === "string" ? value : void 0;
  }
  function getSourceLocationFromDebugSource(fiber) {
    const source = fiber._debugSource;
    if (!source?.fileName || !source.lineNumber) return void 0;
    return `${source.fileName}:${source.lineNumber}:${source.columnNumber ?? 0}`;
  }
  function findSourceLocationInFiber(fiber, depth = 0) {
    if (!fiber || depth > 4) return void 0;
    const ownLocation = getSourceLocationFromProps(fiber.memoizedProps) || getSourceLocationFromDebugSource(fiber);
    if (ownLocation) return ownLocation;
    return findSourceLocationInFiber(fiber.child, depth + 1) || findSourceLocationInFiber(fiber.sibling, depth + 1);
  }
  function getRootFiber() {
    const candidates = [document.getElementById("root"), document.getElementById("app"), document.body];
    for (const element of candidates) {
      if (!element) continue;
      const key = Object.getOwnPropertyNames(element).find((k) => k.startsWith("__reactContainer$"));
      if (!key) continue;
      const hostRoot = element[key];
      const current = hostRoot?.stateNode?.current;
      return current || hostRoot;
    }
    return null;
  }
  function walkFibers(fiber, visitor, maxFibers = MAX_TARGET_SEARCH_FIBERS) {
    const stack = fiber ? [fiber] : [];
    let visited = 0;
    while (stack.length > 0 && visited < maxFibers) {
      const current = stack.pop();
      if (!current) continue;
      visited++;
      visitor(current);
      if (current.sibling) stack.push(current.sibling);
      if (current.child) stack.push(current.child);
    }
    return {
      visited,
      hitLimit: stack.length > 0
    };
  }

  // src/builder-bridge/react-inspector/sanitizer.ts
  var SENSITIVE_FIELD_PATTERN = "password|token|secret|authorization|cookie|api[_-]?key|access[_-]?token|refresh[_-]?token|auth[_-]?token|jwt";
  var SENSITIVE_QUERY_RE = new RegExp(
    `([?&][^=&#]*(?:${SENSITIVE_FIELD_PATTERN})[^=&#]*=)[^&#]*`,
    "gi"
  );
  var SENSITIVE_ASSIGNMENT_RE = new RegExp(
    `(\\b(?:${SENSITIVE_FIELD_PATTERN})\\s*[=:]\\s*)[^\\s&;,]+`,
    "gi"
  );
  var BEARER_TOKEN_RE = /(bearer\s+)[a-z0-9._~+/=-]+/gi;
  var JWT_PATTERN = /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g;
  var isElement2 = (value) => typeof Element !== "undefined" && value instanceof Element;
  var isDomNode = (value) => typeof Node !== "undefined" && value instanceof Node;
  function redactSensitiveString(value) {
    return value.replace(SENSITIVE_QUERY_RE, "$1[REDACTED]").replace(SENSITIVE_ASSIGNMENT_RE, "$1[REDACTED]").replace(BEARER_TOKEN_RE, "$1[REDACTED]").replace(JWT_PATTERN, "[REDACTED]");
  }
  function truncateString3(value) {
    const redacted = redactSensitiveString(value);
    return redacted.length > MAX_STRING_LENGTH2 ? `${redacted.slice(0, MAX_STRING_LENGTH2)}...[truncated]` : redacted;
  }
  function sanitizeForReactDebug(value, warnings = [], depth = 0, seen = /* @__PURE__ */ new WeakSet()) {
    if (value === null || typeof value === "boolean" || typeof value === "number") return value;
    if (typeof value === "string") return truncateString3(value);
    if (typeof value === "bigint") return value.toString();
    if (typeof value === "undefined") return "[undefined]";
    if (typeof value === "function") return "[Function]";
    if (typeof value === "symbol") return value.toString();
    if (isDomNode(value)) return "[DOMNode]";
    if (value instanceof Date) return value.toISOString();
    if (value instanceof Error) {
      return {
        name: truncateString3(value.name || "Error"),
        message: truncateString3(value.message)
      };
    }
    if (typeof value !== "object") return String(value);
    if (seen.has(value)) return "[Circular]";
    seen.add(value);
    const maybeReactElement = value;
    if (maybeReactElement.$$typeof && value.props !== void 0) {
      return "[ReactElement]";
    }
    if (depth >= MAX_OBJECT_DEPTH) {
      warnOnce3(warnings, `React debug data exceeded max depth (${MAX_OBJECT_DEPTH}).`);
      return "[MaxDepth]";
    }
    if (Array.isArray(value)) {
      if (value.length > MAX_ARRAY_ITEMS) {
        warnOnce3(warnings, `React debug arrays were truncated to ${MAX_ARRAY_ITEMS} items.`);
      }
      return value.slice(0, MAX_ARRAY_ITEMS).map((item) => sanitizeForReactDebug(item, warnings, depth + 1, seen));
    }
    const out = {};
    const keys = Object.keys(value);
    if (keys.length > MAX_OBJECT_KEYS) {
      warnOnce3(warnings, `React debug objects were truncated to ${MAX_OBJECT_KEYS} keys.`);
    }
    for (const key of keys.slice(0, MAX_OBJECT_KEYS)) {
      if (REDACT_KEY_RE.test(key)) {
        out[key] = "[REDACTED]";
        continue;
      }
      try {
        out[key] = sanitizeForReactDebug(value[key], warnings, depth + 1, seen);
      } catch (error) {
        out[key] = `[Unserializable: ${error instanceof Error ? error.message : String(error)}]`;
      }
    }
    return out;
  }

  // src/builder-bridge/react-inspector/hooks.ts
  function toDebugKey(value) {
    return value.replace(/[^a-zA-Z0-9_$]+/g, "_").replace(/^_+|_+$/g, "") || "state";
  }
  function ensureUniqueLabels(labels) {
    const counts = {};
    return labels.map((label) => {
      const base = toDebugKey(label.value);
      counts[base] = (counts[base] ?? 0) + 1;
      return { ...label, value: counts[base] === 1 ? base : `${base}_${counts[base]}` };
    });
  }
  function firstIdentifier(value) {
    return value.match(/[a-zA-Z_$][\w$]*/)?.[0];
  }
  function labelFromObjectPattern(pattern, hook) {
    const dataAlias = pattern.match(/\bdata\s*:\s*([a-zA-Z_$][\w$]*)/);
    if (dataAlias?.[1]) return `${hook}_${dataAlias[1]}`;
    const firstProperty = firstIdentifier(pattern);
    return firstProperty ? `${hook}_${firstProperty}` : hook;
  }
  function getHookStateLabels(type) {
    const fn = getRenderFn(type);
    if (!fn) return [];
    const src = fn.toString().replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
    const matches = [];
    const hookCallPrefix = String.raw`(?:\(\s*0\s*,\s*)?(?:[a-zA-Z_$][\w$]*\.)?`;
    const directStateRe = new RegExp(
      String.raw`(?:const|let|var)\s*\[\s*([a-zA-Z_$][\w$]*)\s*(?:,\s*([a-zA-Z_$][\w$]*))?\s*\]\s*=\s*${hookCallPrefix}(useState|useReducer)\)?\b`,
      "g"
    );
    const queryObjectRe = new RegExp(
      String.raw`(?:const|let|var)\s*\{([\s\S]*?)\}\s*=\s*${hookCallPrefix}(useQuery|useInfiniteQuery|useSuspenseQuery|useQueries)\)?\b`,
      "g"
    );
    const customHookRe = new RegExp(
      String.raw`(?:const|let|var)\s+([a-zA-Z_$][\w$]*)\s*=\s*${hookCallPrefix}(useQuery|useInfiniteQuery|useSuspenseQuery|useQueries|useMutation)\)?\b`,
      "g"
    );
    let match;
    while ((match = directStateRe.exec(src)) !== null) {
      matches.push({ index: match.index, value: match[1], hook: match[3] });
    }
    while ((match = queryObjectRe.exec(src)) !== null) {
      matches.push({ index: match.index, value: labelFromObjectPattern(match[1], match[2]), hook: match[2] });
    }
    while ((match = customHookRe.exec(src)) !== null) {
      matches.push({ index: match.index, value: match[1], hook: match[2] });
    }
    return ensureUniqueLabels(matches.sort((a, b) => a.index - b.index).map(({ value, hook }) => ({ value, hook })));
  }
  function isRecord(value) {
    return !!value && typeof value === "object" && !Array.isArray(value);
  }
  var REACT_QUERY_OPTION_KEYS = [
    "queryKey",
    "queryHash",
    "mutationKey",
    "enabled",
    "retry",
    "refetchOnWindowFocus",
    "refetchOnReconnect",
    "staleTime",
    "gcTime",
    "throwOnError"
  ];
  var REACT_QUERY_RESULT_KEYS = [
    "status",
    "fetchStatus",
    "isLoading",
    "isFetching",
    "isPending",
    "isSuccess",
    "isError",
    "isStale",
    "data",
    "error",
    "dataUpdatedAt",
    "errorUpdatedAt",
    "failureCount"
  ];
  var REACT_QUERY_MUTATION_RESULT_KEYS = [
    "status",
    "isPending",
    "isSuccess",
    "isError",
    "variables",
    "data",
    "error",
    "submittedAt",
    "failureCount"
  ];
  function copySanitizedKeys(target, source, keys, warnings) {
    for (const key of keys) {
      if (source[key] !== void 0) target[key] = sanitizeForReactDebug(source[key], warnings);
    }
  }
  function summarizeObserverResult(observer, observerType, summary, warnings) {
    if (typeof observer.getCurrentResult !== "function") {
      warnOnce3(warnings, `React Query ${observerType} observer did not expose getCurrentResult; captured metadata only.`);
      return;
    }
    try {
      const result2 = observer.getCurrentResult.call(observer);
      if (!isRecord(result2)) {
        warnOnce3(warnings, `React Query ${observerType} observer returned a non-object result; captured metadata only.`);
        return;
      }
      copySanitizedKeys(
        summary,
        result2,
        observerType === "mutation" ? REACT_QUERY_MUTATION_RESULT_KEYS : REACT_QUERY_RESULT_KEYS,
        warnings
      );
    } catch (error) {
      const message = error instanceof Error ? error.message : String(error);
      warnOnce3(warnings, `React Query ${observerType} observer result could not be read: ${truncateString3(message)}`);
    }
  }
  function summarizeKnownHookState(value, label, warnings) {
    if (!label || !isRecord(value) || !isRecord(value.options)) return sanitizeForReactDebug(value, warnings);
    const options = value.options;
    const canReadObserverResult = typeof value.getCurrentResult === "function";
    const isQueryHook = label.hook.includes("Query") || label.hook === "useQueries";
    const isQueryObserver = isQueryHook && (options.queryKey !== void 0 || value.refetch !== void 0 || canReadObserverResult);
    const isMutationObserver = label.hook === "useMutation" && (options.mutationKey !== void 0 || value.mutate !== void 0 || canReadObserverResult);
    if (!isQueryObserver && !isMutationObserver) return sanitizeForReactDebug(value, warnings);
    const summary = {
      type: isMutationObserver ? "react-query-mutation-observer" : "react-query-observer"
    };
    copySanitizedKeys(summary, options, REACT_QUERY_OPTION_KEYS, warnings);
    summarizeObserverResult(value, isMutationObserver ? "mutation" : "query", summary, warnings);
    return summary;
  }
  function extractState(fiber, warnings) {
    const labels = getHookStateLabels(fiber.type);
    const state = {};
    let hook = fiber.memoizedState;
    let stateIndex = 0;
    while (hook) {
      if (hook.queue && hook.queue.dispatch) {
        const label = labels[stateIndex];
        const name = label?.value || `state_${stateIndex}`;
        state[name] = summarizeKnownHookState(hook.memoizedState, label, warnings);
        stateIndex++;
      }
      hook = hook.next ?? null;
    }
    return { state, hookNamesRecovered: labels.length > 0 };
  }

  // src/builder-bridge/react-inspector/components.ts
  var PLATFORM_COMPONENT_DENYLIST = /* @__PURE__ */ new Set([
    "AuthProvider",
    // Base44 auth wrapper — carries full user object
    "QueryClientProvider",
    // react-query — carries the entire query cache
    "BrowserRouter",
    // react-router internal
    "Router",
    // react-router internal
    "Routes",
    // react-router internal
    "RenderedRoute"
    // react-router internal
  ]);
  function inspectFunctionFiber(fiber, depth, warnings) {
    const { state, hookNamesRecovered } = extractState(fiber, warnings);
    const props = sanitizeForReactDebug(fiber.memoizedProps ?? {}, warnings);
    return {
      name: getComponentName(fiber),
      depth,
      sourceLocation: findSourceLocationInFiber(fiber),
      props,
      state,
      stateKeys: Object.keys(state),
      hookNamesRecovered
    };
  }
  function inspectFiberForDebug(fiber, depth, warnings) {
    return inspectFunctionFiber(fiber, depth, warnings);
  }
  function describeElement(element) {
    const tag = element.tagName.toLowerCase();
    const id = element.id ? `#${element.id}` : "";
    const classTokens = typeof element.className === "string" ? element.className.split(/\s+/).filter(Boolean).slice(0, 2) : [];
    const className = classTokens.length ? `.${classTokens.join(".")}` : "";
    const text = element.textContent?.trim().replace(/\s+/g, " ").slice(0, 60);
    return `<${tag}${id}${className}>${text ? ` "${text}"` : ""}`;
  }
  function closestSourceLocation(element) {
    const sourceElement = element.closest("[data-source-location]");
    const sourceLocation = sourceElement?.getAttribute("data-source-location");
    return sourceLocation || void 0;
  }
  function inspectFiberAncestors(fiber, warnings = []) {
    const out = [];
    let depth = 0;
    while (fiber && out.length < MAX_COMPONENT_STACK_DEPTH) {
      if (isFunctionComponent(fiber)) {
        if (!PLATFORM_COMPONENT_DENYLIST.has(getComponentName(fiber))) {
          out.push(inspectFunctionFiber(fiber, depth, warnings));
          depth++;
        }
      }
      fiber = fiber.return ?? null;
    }
    if (fiber) {
      warnOnce3(warnings, `React component stack was truncated to ${MAX_COMPONENT_STACK_DEPTH} components.`);
    }
    return out;
  }
  function inspectReactAll(element, warnings = []) {
    return inspectFiberAncestors(getFiber(element), warnings);
  }
  function inspectReact(element, warnings = []) {
    return inspectReactAll(element, warnings)[0] ?? null;
  }

  // src/builder-bridge/react-inspector/targets.ts
  function normalizeTargetIndex(index2) {
    return typeof index2 === "number" && Number.isFinite(index2) && index2 > 0 ? Math.floor(index2) : 0;
  }
  function sanitizeTargetRequest(target) {
    if (target.kind === "css-selector") return { ...target, selector: truncateString3(target.selector) };
    if (target.kind === "source-location") return { ...target, sourceLocation: truncateString3(target.sourceLocation) };
    if (target.kind === "component-name") {
      return {
        ...target,
        name: truncateString3(target.name),
        sourceLocation: target.sourceLocation ? truncateString3(target.sourceLocation) : void 0
      };
    }
    return target;
  }
  function sourceLocationMatches(actual, expected, match = "exact") {
    if (!actual) return false;
    if (match === "startsWith") return actual.startsWith(expected);
    if (match === "includes") return actual.includes(expected);
    return actual === expected;
  }
  function inspectElementTarget(request, element, matchCount, warnings) {
    const componentStack = element ? inspectReactAll(element, warnings) : [];
    const resolved = componentStack.length > 0;
    if (element && !resolved) {
      warnOnce3(warnings, "React debug target matched a DOM element but no React component ancestor was found.");
    }
    return {
      request: sanitizeTargetRequest(request),
      resolved,
      ...element && { target: describeElement(element) },
      ...element && { sourceLocation: closestSourceLocation(element) },
      ...matchCount !== void 0 && { matchCount },
      componentStack
    };
  }
  function inspectLastInteractionTarget(request, lastInteraction2, warnings) {
    if (!lastInteraction2) {
      warnOnce3(warnings, "React debug target requested last interaction, but no interaction was captured yet.");
      return { request, resolved: false, matchCount: 0, componentStack: [] };
    }
    return {
      request,
      resolved: lastInteraction2.componentStack.length > 0,
      target: lastInteraction2.target,
      sourceLocation: lastInteraction2.sourceLocation,
      matchCount: 1,
      componentStack: lastInteraction2.componentStack
    };
  }
  function resolveCssSelectorTarget(request, warnings) {
    if (!request.selector || request.selector.length > MAX_TARGET_QUERY_LENGTH) {
      warnOnce3(warnings, `React debug CSS selector target must be between 1 and ${MAX_TARGET_QUERY_LENGTH} characters.`);
      return inspectElementTarget(request, null, 0, warnings);
    }
    try {
      const matches = Array.from(document.querySelectorAll(request.selector));
      const index2 = normalizeTargetIndex(request.index);
      if (matches.length === 0 || !matches[index2]) {
        warnOnce3(warnings, "React debug CSS selector target did not match an element.");
      }
      return inspectElementTarget(request, matches[index2] ?? null, matches.length, warnings);
    } catch (error) {
      warnOnce3(warnings, `React debug CSS selector target was invalid: ${error instanceof Error ? error.message : String(error)}.`);
      return inspectElementTarget(request, null, 0, warnings);
    }
  }
  function resolveSourceLocationTarget(request, warnings) {
    if (!request.sourceLocation || request.sourceLocation.length > MAX_TARGET_QUERY_LENGTH) {
      warnOnce3(warnings, `React debug source-location target must be between 1 and ${MAX_TARGET_QUERY_LENGTH} characters.`);
      return inspectElementTarget(request, null, 0, warnings);
    }
    const matches = Array.from(document.querySelectorAll("[data-source-location]")).filter((element) => sourceLocationMatches(
      element.getAttribute("data-source-location") ?? void 0,
      request.sourceLocation,
      request.match
    ));
    const index2 = normalizeTargetIndex(request.index);
    if (matches.length === 0 || !matches[index2]) {
      warnOnce3(warnings, "React debug source-location target did not match an element.");
    }
    return inspectElementTarget(request, matches[index2] ?? null, matches.length, warnings);
  }
  function findComponentNameMatch(request, warnings) {
    const targetIndex = normalizeTargetIndex(request.index);
    let matchCount = 0;
    let selectedFiber = null;
    const walkResult = walkFibers(getRootFiber(), (fiber) => {
      if (isFunctionComponent(fiber) && getComponentName(fiber) === request.name) {
        const sourceLocation = findSourceLocationInFiber(fiber);
        if (!request.sourceLocation || sourceLocationMatches(sourceLocation, request.sourceLocation, request.match)) {
          if (matchCount === targetIndex) selectedFiber = fiber;
          matchCount++;
        }
      }
    });
    if (walkResult.hitLimit) {
      warnOnce3(warnings, `React debug component-name target search stopped after ${walkResult.visited} fibers.`);
    }
    return { selectedFiber, matchCount };
  }
  function resolveComponentNameTarget(request, warnings) {
    if (!request.name || request.name.length > MAX_TARGET_QUERY_LENGTH) {
      warnOnce3(warnings, `React debug component-name target must be between 1 and ${MAX_TARGET_QUERY_LENGTH} characters.`);
      return { request: sanitizeTargetRequest(request), resolved: false, matchCount: 0, componentStack: [] };
    }
    const { selectedFiber, matchCount } = findComponentNameMatch(request, warnings);
    if (!selectedFiber) warnOnce3(warnings, "React debug component-name target did not match a component.");
    const componentStack = selectedFiber ? inspectFiberAncestors(selectedFiber, warnings) : [];
    const sourceLocation = selectedFiber ? findSourceLocationInFiber(selectedFiber) : void 0;
    return {
      request: sanitizeTargetRequest(request),
      resolved: componentStack.length > 0,
      ...selectedFiber && { target: `<${request.name}>` },
      ...sourceLocation && { sourceLocation },
      matchCount,
      componentStack
    };
  }
  function inspectRequestedTarget(target, lastInteraction2, warnings) {
    if (!target) return void 0;
    if (target.kind === "last-interaction") return inspectLastInteractionTarget(target, lastInteraction2, warnings);
    if (target.kind === "css-selector") return resolveCssSelectorTarget(target, warnings);
    if (target.kind === "source-location") return resolveSourceLocationTarget(target, warnings);
    if (target.kind === "component-name") return resolveComponentNameTarget(target, warnings);
    warnOnce3(warnings, "React debug target kind was not recognized.");
    return void 0;
  }

  // src/builder-bridge/react-inspector/tree.ts
  function getFullTreeDepth(fiber) {
    let depth = 0;
    let current = fiber.return ?? null;
    while (current) {
      if (isFunctionComponent(current) && !PLATFORM_COMPONENT_DENYLIST.has(getComponentName(current))) {
        depth++;
      }
      current = current.return ?? null;
    }
    return depth;
  }
  function collectFullTree(warnings) {
    const root2 = getRootFiber();
    const components = [];
    let total = 0;
    const walkResult = walkFibers(root2, (fiber) => {
      if (!isFunctionComponent(fiber)) return;
      if (PLATFORM_COMPONENT_DENYLIST.has(getComponentName(fiber))) return;
      total++;
      if (components.length < MAX_FULL_TREE_COMPONENTS) {
        components.push(inspectFiberForDebug(fiber, getFullTreeDepth(fiber), warnings));
      }
    });
    const truncated = walkResult.hitLimit || total > components.length;
    if (total > components.length) {
      warnOnce3(warnings, `React full-tree snapshot was truncated to ${MAX_FULL_TREE_COMPONENTS} components.`);
    }
    if (walkResult.hitLimit) {
      warnOnce3(warnings, `React full-tree fiber scan stopped after ${walkResult.visited} fibers; total may be undercounted.`);
    }
    return { total, truncated, components };
  }
  function collectDebugRegistry(warnings) {
    const registry = window.$debug;
    if (!registry || typeof registry !== "object") return void 0;
    const out = {};
    for (const key of Object.keys(registry).slice(0, MAX_OBJECT_KEYS)) {
      if (REDACT_KEY_RE.test(key)) {
        out[key] = "[REDACTED]";
        continue;
      }
      try {
        out[key] = sanitizeForReactDebug(registry[key], warnings);
      } catch (error) {
        out[key] = `[Unserializable: ${error instanceof Error ? error.message : String(error)}]`;
      }
    }
    return out;
  }
  function getReactPayloadSize(snapshot2) {
    try {
      return new Blob([JSON.stringify(snapshot2)]).size;
    } catch {
      return MAX_REACT_PAYLOAD_BYTES + 1;
    }
  }
  function enforcePayloadLimit(snapshot2) {
    if (getReactPayloadSize(snapshot2) <= MAX_REACT_PAYLOAD_BYTES) return snapshot2;
    const warnings = [...snapshot2.warnings ?? []];
    warnOnce3(warnings, "React debug payload exceeded 200KB and was trimmed.");
    const trimmed = {
      ...snapshot2,
      warnings,
      ...snapshot2.fullTree && {
        fullTree: {
          ...snapshot2.fullTree,
          components: [...snapshot2.fullTree.components]
        }
      }
    };
    if (trimmed.fullTree) {
      while (trimmed.fullTree.components.length > 0 && getReactPayloadSize(trimmed) > MAX_REACT_PAYLOAD_BYTES) {
        const nextComponentCount = Math.floor(trimmed.fullTree.components.length / 2);
        trimmed.fullTree.components = trimmed.fullTree.components.slice(
          0,
          nextComponentCount
        );
        trimmed.fullTree.truncated = true;
      }
    }
    if (getReactPayloadSize(trimmed) > MAX_REACT_PAYLOAD_BYTES) {
      delete trimmed.debugRegistry;
      warnOnce3(warnings, "React debug registry was omitted to keep the payload under 200KB.");
    }
    return trimmed;
  }

  // src/builder-bridge/react-inspector/index.ts
  var reactDebugEnabled = false;
  var listenersInstalled = false;
  var interactionCallback = null;
  var lastInteraction;
  var lastInteractionElement = null;
  function recordInteraction(type, event) {
    if (!isElement2(event.target)) return;
    const target = event.target;
    window.setTimeout(() => {
      const warnings = [];
      const componentStack = reactDebugEnabled ? inspectReactAll(target, warnings) : [];
      lastInteractionElement = target;
      lastInteraction = {
        type,
        target: describeElement(target),
        sourceLocation: closestSourceLocation(target),
        componentStack
      };
      if (reactDebugEnabled) interactionCallback?.();
    }, 0);
  }
  function hydrateLastInteraction(warnings) {
    if (!lastInteraction || !lastInteractionElement || lastInteraction.componentStack.length > 0) return;
    lastInteraction = {
      ...lastInteraction,
      componentStack: inspectReactAll(lastInteractionElement, warnings)
    };
  }
  function installListeners() {
    if (listenersInstalled) return;
    listenersInstalled = true;
    document.addEventListener("click", (event) => recordInteraction("click", event), true);
    document.addEventListener("input", (event) => recordInteraction("input", event), true);
    document.addEventListener("change", (event) => recordInteraction("change", event), true);
    document.addEventListener("submit", (event) => recordInteraction("submit", event), true);
  }
  function setupReactInspector(onInteraction) {
    interactionCallback = onInteraction ?? null;
    installListeners();
  }
  function setReactDebugEnabled(enabled) {
    reactDebugEnabled = enabled;
    installListeners();
    const win = window;
    if (!enabled) {
      delete win.$r;
      delete win.$rAll;
      delete win.$components;
      lastInteraction = void 0;
      lastInteractionElement = null;
      return;
    }
    if (!win.$debug) win.$debug = {};
    win.$r = (element) => inspectReact(element);
    win.$rAll = (element) => inspectReactAll(element);
    Object.defineProperty(win, "$components", {
      get: () => collectFullTree([]),
      configurable: true,
      enumerable: false
    });
  }
  function collectReactDebugSnapshot(options) {
    if (!reactDebugEnabled) return void 0;
    const warnings = [];
    hydrateLastInteraction(warnings);
    const fullTree = options.includeFullTree ? collectFullTree(warnings) : void 0;
    const selectedTarget = inspectRequestedTarget(options.target, lastInteraction, warnings);
    const debugRegistry = collectDebugRegistry(warnings);
    const reactDetected = Boolean(
      fullTree?.total || selectedTarget?.componentStack.length || lastInteraction?.componentStack.length || getRootFiber()
    );
    if (!reactDetected) warnOnce3(warnings, "React internals were not found in the preview document.");
    const snapshot2 = {
      capturedAt: Date.now(),
      reactDetected,
      reason: options.reason,
      ...lastInteraction && { lastInteraction },
      ...selectedTarget && { selectedTarget },
      ...debugRegistry && { debugRegistry },
      ...fullTree && { fullTree },
      ...warnings.length > 0 && { warnings }
    };
    return enforcePayloadLimit(snapshot2);
  }

  // src/builder-bridge/preview-lens/utils/byte-cap.ts
  var textEncoder = new TextEncoder();
  function utf8ByteLength(value) {
    return textEncoder.encode(value).byteLength;
  }
  function truncateToByteLength(value, maxBytes) {
    if (maxBytes <= 0) return "";
    const encoded = textEncoder.encode(value);
    if (encoded.byteLength <= maxBytes) return value;
    const sliced = encoded.subarray(0, maxBytes);
    return new TextDecoder("utf-8", { fatal: false }).decode(sliced).replace(/�+$/, "");
  }
  var TRUNCATION_MARKER_TEMPLATE = (omittedByteCount) => `...truncated, ${omittedByteCount} bytes omitted`;
  function applyByteCap(serialized, byteCap) {
    const originalByteLength = utf8ByteLength(serialized);
    if (originalByteLength <= byteCap) {
      return { serialized, wasTruncated: false, originalByteLength };
    }
    let marker = TRUNCATION_MARKER_TEMPLATE(originalByteLength - byteCap);
    let headroomForContent = byteCap - utf8ByteLength(marker);
    marker = TRUNCATION_MARKER_TEMPLATE(originalByteLength - Math.max(0, headroomForContent));
    headroomForContent = byteCap - utf8ByteLength(marker);
    const truncatedSerialization = truncateToByteLength(serialized, Math.max(0, headroomForContent)) + marker;
    return { serialized: truncatedSerialization, wasTruncated: true, originalByteLength };
  }

  // src/builder-bridge/preview-lens/utils/redact.ts
  var REDACTED_PLACEHOLDER = "[REDACTED]";
  var SENSITIVE_KEY_PATTERN = /(authorization|cookie|set-cookie|password|passwd|secret|token|api[-_]?key|access[-_]?key|client[-_]?secret|x-api-key|session[-_]?id|bearer|credential|private[-_]?key)/i;
  function isSensitiveKey(key) {
    return SENSITIVE_KEY_PATTERN.test(key);
  }
  var JWT_PATTERN2 = /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g;
  function redactBareJwts(text) {
    return text.replace(JWT_PATTERN2, REDACTED_PLACEHOLDER);
  }
  function redactDeep(value, depth = 0) {
    if (depth > 8 || value === null) return value;
    if (typeof value === "string") return redactBareJwts(redactUrlCredentials(value));
    if (typeof value !== "object") return value;
    if (Array.isArray(value)) return value.map((item) => redactDeep(item, depth + 1));
    const redacted = {};
    for (const [key, nested] of Object.entries(value)) {
      redacted[key] = isSensitiveKey(key) ? REDACTED_PLACEHOLDER : redactDeep(nested, depth + 1);
    }
    return redacted;
  }
  function redactString(text) {
    if (typeof text !== "string" || text.length === 0) return text;
    const trimmed = text.trim();
    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
      try {
        return JSON.stringify(redactDeep(JSON.parse(trimmed)));
      } catch {
      }
    }
    const bearerMasked = text.replace(
      /\b(Bearer)\s+[A-Za-z0-9._~+/-]+=*/gi,
      `$1 ${REDACTED_PLACEHOLDER}`
    );
    const keyValueMasked = bearerMasked.replace(
      /(^|[\s,{;&"'])([A-Za-z0-9_.\-]+)(["']?\s*[:=]\s*)("[^"]*"|'[^']*'|[^\s,&;]+)/g,
      (whole, pre, key, sep2) => isSensitiveKey(key) ? `${pre}${key}${sep2}${REDACTED_PLACEHOLDER}` : whole
    );
    return redactBareJwts(redactUrlCredentials(keyValueMasked));
  }
  function redactParamString(params) {
    return params.replace(
      /([^=&]+)=([^&]*)/g,
      (whole, key) => isSensitiveKey(key) ? `${key}=${REDACTED_PLACEHOLDER}` : whole
    );
  }
  function redactUrlCredentials(url) {
    if (typeof url !== "string") return url;
    const hashIndex = url.indexOf("#");
    const beforeHash = hashIndex === -1 ? url : url.slice(0, hashIndex);
    const fragment = hashIndex === -1 ? "" : url.slice(hashIndex + 1);
    let result2 = beforeHash;
    const queryIndex = beforeHash.indexOf("?");
    if (queryIndex !== -1) {
      result2 = `${beforeHash.slice(0, queryIndex)}?${redactParamString(beforeHash.slice(queryIndex + 1))}`;
    }
    if (hashIndex !== -1) {
      result2 = `${result2}#${redactParamString(fragment)}`;
    }
    return result2;
  }
  function redactedCurrentHref() {
    return redactUrlCredentials(window.location.href);
  }

  // src/builder-bridge/preview-lens/helper-telemetry.ts
  var helperCallRecords = [];
  var inFlightHelper = null;
  var nextEvalGeneration = 0;
  var activeEvalGeneration = null;
  var activeEvalDeadlineMs = null;
  function currentEvalGeneration() {
    return activeEvalGeneration;
  }
  function setEvalDeadline(evalGeneration, deadlineMs) {
    if (!isCurrentEvalGeneration(evalGeneration)) return;
    activeEvalDeadlineMs = deadlineMs;
  }
  function remainingEvalMs(evalGeneration) {
    if (!isCurrentEvalGeneration(evalGeneration) || activeEvalDeadlineMs === null) return null;
    return Math.max(0, activeEvalDeadlineMs - performance.now());
  }
  function isCurrentEvalGeneration(evalGeneration) {
    return evalGeneration === activeEvalGeneration;
  }
  function resetHelperCallTelemetry() {
    helperCallRecords = [];
    inFlightHelper = null;
    nextEvalGeneration += 1;
    activeEvalGeneration = nextEvalGeneration;
    return activeEvalGeneration;
  }
  function recordHelperCall(evalGeneration, record2) {
    if (!isCurrentEvalGeneration(evalGeneration)) return;
    helperCallRecords.push(record2);
  }
  function markHelperInFlight(evalGeneration, helperName, startedAtMs) {
    if (!isCurrentEvalGeneration(evalGeneration)) return;
    inFlightHelper = { helper_name: helperName, started_at_ms: startedAtMs };
  }
  function clearHelperInFlight(evalGeneration) {
    if (!isCurrentEvalGeneration(evalGeneration)) return;
    inFlightHelper = null;
  }
  function drainHelperCallTelemetry() {
    const records = [...helperCallRecords];
    const inFlightName = inFlightHelper?.helper_name ?? null;
    if (inFlightHelper) {
      records.push({
        helper_name: inFlightHelper.helper_name,
        duration_ms: Math.round(performance.now() - inFlightHelper.started_at_ms)
      });
    }
    helperCallRecords = [];
    inFlightHelper = null;
    activeEvalGeneration = null;
    activeEvalDeadlineMs = null;
    const byName = /* @__PURE__ */ new Map();
    for (const record2 of records) {
      const summary = byName.get(record2.helper_name);
      if (summary) {
        summary.count += 1;
        summary.total_ms += record2.duration_ms;
        summary.max_ms = Math.max(summary.max_ms, record2.duration_ms);
      } else {
        byName.set(record2.helper_name, {
          helper_name: record2.helper_name,
          count: 1,
          total_ms: record2.duration_ms,
          max_ms: record2.duration_ms
        });
      }
    }
    if (inFlightName) {
      const summary = byName.get(inFlightName);
      if (summary) summary.in_flight = true;
    }
    return Array.from(byName.values());
  }
  var helperFailureByError = /* @__PURE__ */ new WeakMap();
  function tagHelperFailure(error, provenance) {
    if (error && typeof error === "object") helperFailureByError.set(error, provenance);
  }
  function readHelperFailure(error) {
    return error && typeof error === "object" ? helperFailureByError.get(error) : void 0;
  }

  // src/builder-bridge/preview-lens/types.ts
  var PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES = {
    TIMEOUT: "timeout",
    NOT_SERIALIZABLE: "not_serializable",
    NAVIGATION_FAILED: "navigation_failed",
    BRIDGE_ERROR: "bridge_error",
    BLANK_RENDER: "blank_render",
    AGENT_CODE_ERROR: "agent_code_error",
    IFRAME_HIDDEN: "iframe_hidden",
    UNKNOWN: "unknown"
  };
  var ELEMENT_TARGET_CONTRACT_VERSION = "v2";

  // src/builder-bridge/preview-lens/utils/details.ts
  function firstDetailsSummary(details) {
    return Array.from(details.children).find((child) => child.localName === "summary") ?? null;
  }
  function isClosedDetails(element) {
    return element.localName === "details" && !element.hasAttribute("open");
  }

  // src/builder-bridge/preview-lens/utils/visibility.ts
  var NON_RENDERED_CONTENT_TAGS = /* @__PURE__ */ new Set([
    "desc",
    "link",
    "meta",
    "noscript",
    "script",
    "style",
    "template",
    "title"
  ]);
  function isElementHidden(element) {
    if (element.hasAttribute("hidden")) return true;
    if (element.getAttribute("aria-hidden") === "true") return true;
    const ownerWindow = element.ownerDocument?.defaultView;
    if (ownerWindow && typeof ownerWindow.getComputedStyle === "function") {
      const computedStyle = ownerWindow.getComputedStyle(element);
      if (computedStyle.display === "none" || computedStyle.visibility === "hidden") return true;
    }
    return false;
  }
  function isElementOrAncestorHidden(element) {
    if (isHiddenByClosedDetails(element)) return true;
    for (let node2 = element; node2; node2 = node2.parentElement) {
      if (isElementHidden(node2)) return true;
    }
    return false;
  }
  function isElementUnavailable(element) {
    return element.hasAttribute("inert") || isElementHidden(element) || isHiddenByClosedDetails(element);
  }
  function isNonRenderedContentElement(element) {
    return NON_RENDERED_CONTENT_TAGS.has(element.localName);
  }
  function activeModalDialog(document2) {
    const modalDialogs = Array.from(document2.querySelectorAll("dialog[open]")).filter((dialog) => {
      try {
        return dialog.matches(":modal");
      } catch {
        return false;
      }
    });
    const focusedDialog = document2.activeElement?.closest("dialog[open]");
    return modalDialogs.find((dialog) => dialog === focusedDialog) ?? modalDialogs[modalDialogs.length - 1] ?? null;
  }
  function isElementBlockedByModal(element) {
    const modalDialog = activeModalDialog(element.ownerDocument);
    return !!modalDialog && element !== modalDialog && !modalDialog.contains(element);
  }
  function isElementBlockedByInert(element) {
    const modalDialog = activeModalDialog(element.ownerDocument);
    for (let node2 = element; node2; node2 = node2.parentElement) {
      if (node2.hasAttribute("inert")) return true;
      if (node2 === modalDialog) break;
    }
    return false;
  }
  function isHiddenByClosedDetails(element) {
    for (let details = element.closest("details:not([open])"); details; details = details.parentElement?.closest("details:not([open])") ?? null) {
      if (details !== element && !firstDetailsSummary(details)?.contains(element)) return true;
    }
    return false;
  }
  function isElementOrAncestorUnavailable(element, modalDialog = activeModalDialog(element.ownerDocument)) {
    if (modalDialog && element !== modalDialog && !modalDialog.contains(element)) return true;
    for (let node2 = element; node2; node2 = node2.parentElement) {
      if (isElementUnavailable(node2)) return true;
      if (node2 === modalDialog) break;
    }
    return false;
  }
  function visibleTextContent(element, availability = "available") {
    return textContent2(element, void 0, false, availability, activeModalDialog(element.ownerDocument));
  }
  function accessibleTextContent(element, excludedSubtree, availability = "available") {
    return textContent2(element, excludedSubtree, true, availability, activeModalDialog(element.ownerDocument));
  }
  function textContent2(element, excludedSubtree, includeAccessibleReplacements, availability, modalDialog) {
    if (element === excludedSubtree) return "";
    if (!includeAccessibleReplacements && isNonRenderedContentElement(element)) return "";
    if (isCollapsedSelectOption(element)) return "";
    const rootExcluded = availability === "available" ? isElementOrAncestorUnavailable(element, modalDialog) : availability === "interaction" && isElementOrAncestorHidden(element);
    if (rootExcluded) return "";
    return descendantText(
      element,
      excludedSubtree,
      includeAccessibleReplacements,
      availability
    );
  }
  function descendantText(element, excludedSubtree, includeAccessibleReplacements, availability) {
    const directTextIsHidden = availability !== "attached" && isClosedDetails(element);
    return Array.from(element.childNodes).map((node2) => {
      if (node2.nodeType === Node.TEXT_NODE) return directTextIsHidden ? "" : node2.textContent ?? "";
      if (!(node2 instanceof Element) || node2 === excludedSubtree || isNonRenderedContentElement(node2) && !(includeAccessibleReplacements && node2.localName === "title") || isCollapsedSelectOption(node2)) return "";
      if (includeAccessibleReplacements && node2.localName === "title") {
        const titleText = accessibleTitleText(node2, availability === "attached");
        return titleText ? ` ${titleText} ` : "";
      }
      if (availability === "available" && isElementUnavailable(node2)) return "";
      if (availability === "interaction" && isElementOrAncestorHidden(node2)) return "";
      if (includeAccessibleReplacements && node2 instanceof HTMLImageElement) return ` ${node2.alt} `;
      return descendantText(
        node2,
        excludedSubtree,
        includeAccessibleReplacements,
        availability
      );
    }).join("");
  }
  function accessibleTitleText(title, includeUnavailable = false) {
    if (title.localName !== "title") return "";
    if (!includeUnavailable && (title.hasAttribute("hidden") || title.getAttribute("aria-hidden") === "true" || title.hasAttribute("style") && isElementHidden(title))) return "";
    return title.textContent ?? "";
  }
  function isCollapsedSelectOption(element) {
    if (!(element instanceof HTMLOptionElement) || element.selected) return false;
    return collapsedSelectForOption(element) !== null;
  }
  function collapsedSelectForOption(element) {
    if (!(element instanceof HTMLOptionElement)) return null;
    const select = element.closest("select");
    return select && !select.multiple && select.size <= 1 ? select : null;
  }

  // src/builder-bridge/preview-lens/utils/interactivity.ts
  var ACTIVATABLE_SELECTOR = [
    "button",
    "a[href]",
    "input",
    "option",
    "select",
    "textarea",
    "summary",
    '[role="button"]',
    '[role="link"]',
    '[role="menuitem"]',
    '[role="tab"]'
  ].join(",");
  function activationTargetForElement(element) {
    return collapsedSelectForOption(element) ?? element.closest(ACTIVATABLE_SELECTOR) ?? element;
  }
  function clickUnavailableReason(element) {
    const activationTarget = activationTargetForElement(element);
    if (isElementBlockedByModal(element)) {
      return { reason: "behind_modal", message: "element is behind a modal dialog and cannot be clicked" };
    }
    if (isElementBlockedByInert(element)) {
      return { reason: "inert", message: "element is inert and cannot be clicked" };
    }
    if (isDisabledControl(element) || isDisabledControl(activationTarget) || hasDisabledOptionAncestor(element)) return { reason: "disabled", message: "element is disabled and cannot be clicked" };
    if (element.closest('[aria-disabled="true" i]')) {
      return { reason: "aria_disabled", message: "element is aria-disabled and cannot be clicked" };
    }
    if (computedPointerEvents(activationTarget) === "none") {
      return { reason: "pointer_events_none", message: "element has pointer-events: none and cannot be clicked" };
    }
    return null;
  }
  function fillUnavailableReason(element) {
    if (isElementBlockedByModal(element)) {
      return { reason: "behind_modal", message: "element is behind a modal dialog and cannot be filled" };
    }
    if (isElementBlockedByInert(element)) {
      return { reason: "inert", message: "element is inert and cannot be filled" };
    }
    if (isDisabledControl(element) || element.closest('[aria-disabled="true" i]')) {
      return { reason: "disabled", message: "element is disabled and cannot be filled" };
    }
    if ((element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) && element.readOnly) {
      return { reason: "read_only", message: "element is read-only and cannot be filled" };
    }
    if (element.closest('[aria-readonly="true" i]')) {
      return { reason: "read_only", message: "element is read-only and cannot be filled" };
    }
    return null;
  }
  function isDisabledControl(element) {
    return (element instanceof HTMLButtonElement || element instanceof HTMLInputElement || element instanceof HTMLOptionElement || element instanceof HTMLSelectElement || element instanceof HTMLTextAreaElement) && element.matches(":disabled");
  }
  function hasDisabledOptionAncestor(element) {
    if (!(element instanceof HTMLOptionElement)) return false;
    const select = element.closest("select");
    const optgroup = element.closest("optgroup");
    return select?.disabled === true || optgroup instanceof HTMLOptGroupElement && optgroup.disabled;
  }
  function computedPointerEvents(element) {
    return element.ownerDocument?.defaultView?.getComputedStyle(element).pointerEvents ?? "";
  }

  // src/builder-bridge/preview-lens/utils/constants.ts
  var ELEMENT_WAIT_POLL_INTERVAL_MS = 50;
  var ELEMENT_WAIT_TIMEOUT_MS = 1500;
  var RESIZE_ACK_TIMEOUT_MS = 4e3;
  var NAVIGATION_MATCH_TIMEOUT_MS = 3e3;
  var ROUTE_RENDER_TIMEOUT_MS = 8e3;
  var LINK_FALLBACK_RENDER_TIMEOUT_MS = 3e3;
  var EVAL_HELPER_COMPLETION_MARGIN_MS = 500;
  var SAME_ROUTE_QUERY_RENDER_WAIT_MS = 500;
  var RENDER_SETTLE_FALLBACK_MS = 150;

  // src/builder-bridge/preview-lens/utils/element-role.ts
  var TAG_TO_NATIVE_ROLE = {
    aside: "complementary",
    button: "button",
    dialog: "dialog",
    footer: "contentinfo",
    form: "form",
    h1: "heading",
    h2: "heading",
    h3: "heading",
    h4: "heading",
    h5: "heading",
    h6: "heading",
    header: "banner",
    img: "image",
    label: "label",
    li: "listitem",
    main: "main",
    nav: "navigation",
    ol: "list",
    option: "option",
    section: "region",
    table: "table",
    tbody: "rowgroup",
    td: "cell",
    textarea: "textbox",
    th: "columnheader",
    thead: "rowgroup",
    tr: "row",
    ul: "list"
  };
  var CONTROL_ROLE_SELECTORS = {
    button: "input,button,summary",
    checkbox: "input",
    combobox: "input,select",
    link: "a[href],area[href]",
    listbox: "select",
    radio: "input",
    searchbox: "input",
    slider: "input",
    spinbutton: "input",
    textbox: 'input,textarea,[contenteditable=""],[contenteditable="true" i],[contenteditable="plaintext-only" i]'
  };
  function explicitRoleForElement(element) {
    return element.getAttribute("role")?.trim().toLowerCase().split(/\s+/)[0] || null;
  }
  function inferNativeFormControlRole(element) {
    if (element.localName === "summary" && element.parentElement?.localName === "details" && firstDetailsSummary(element.parentElement) === element) return "button";
    if (element instanceof HTMLSelectElement) {
      return element.multiple || element.size > 1 ? "listbox" : "combobox";
    }
    if (element instanceof HTMLInputElement) {
      if (element.type === "file") return null;
      if (element.type === "checkbox" || element.type === "radio") return element.type;
      if (["button", "submit", "reset", "image"].includes(element.type)) return "button";
      if (element.type === "range") return "slider";
      if (element.type === "number") return "spinbutton";
      if (element.type === "search" && !element.hasAttribute("list")) return "searchbox";
      return element.hasAttribute("list") ? "combobox" : "textbox";
    }
    if (element.matches("a[href],area[href]")) return "link";
    if (isContentEditableRoot(element) && !inferNativeTagRole(element)) return "textbox";
    return null;
  }
  function inferRoleForElement(element) {
    return explicitRoleForElement(element) ?? inferNativeFormControlRole(element) ?? inferNativeTagRole(element) ?? element.localName;
  }
  function elementHasRole(element, requestedRole) {
    const explicitRole = explicitRoleForElement(element);
    if (explicitRole) return canonicalRole(explicitRole) === canonicalRole(requestedRole);
    const nativeRole = inferNativeFormControlRole(element) ?? inferNativeTagRole(element);
    return (nativeRole ?? element.localName) === canonicalRole(requestedRole);
  }
  function selectorForRole(requestedRole) {
    const nativeRole = canonicalRole(requestedRole);
    const nativeTags = Object.entries(TAG_TO_NATIVE_ROLE).filter(([, role]) => role === nativeRole).map(([tag]) => tag);
    const controlSelector = CONTROL_ROLE_SELECTORS[nativeRole];
    const explicitRoles = nativeRole === "image" ? ["image", "img"] : [requestedRole];
    return [.../* @__PURE__ */ new Set([
      ...explicitRoles.map((role) => `[role~="${role}"]`),
      ...nativeTags,
      ...controlSelector ? [controlSelector] : [],
      requestedRole
    ])].join(",");
  }
  function canonicalRole(role) {
    return role === "img" ? "image" : role;
  }
  function inferNativeTagRole(element) {
    return TAG_TO_NATIVE_ROLE[element.localName] ?? null;
  }
  function isContentEditableRoot(element) {
    const value = element.getAttribute("contenteditable")?.toLowerCase();
    return element instanceof HTMLElement && (value === "" || value === "true" || value === "plaintext-only");
  }

  // src/builder-bridge/preview-lens/utils/accessible-name.ts
  var NATIVE_NAME_FROM_CONTENT_TAGS = /* @__PURE__ */ new Set([
    "BUTTON",
    "A",
    "AREA",
    "H1",
    "H2",
    "H3",
    "H4",
    "H5",
    "H6",
    "LI",
    "OPTION",
    "SUMMARY"
  ]);
  var ROLE_NAME_FROM_CONTENT = /* @__PURE__ */ new Set([
    "button",
    "cell",
    "checkbox",
    "columnheader",
    "gridcell",
    "heading",
    "link",
    "menuitem",
    "listitem",
    "menuitemcheckbox",
    "menuitemradio",
    "option",
    "radio",
    "row",
    "rowheader",
    "switch",
    "tab",
    "tooltip",
    "treeitem"
  ]);
  function normalizeWhitespace(value) {
    return (value ?? "").replace(/\s+/g, " ").trim();
  }
  function contentName(element, availability) {
    if (availability === "attached" && isCollapsedSelectOption(element)) return element.textContent ?? "";
    return accessibleTextContent(element, void 0, availability);
  }
  function referencedLabelAvailability(labelledElement, targetAvailability) {
    if (isElementOrAncestorHidden(labelledElement)) return "attached";
    if (targetAvailability === "interaction") return "interaction";
    return isElementOrAncestorUnavailable(labelledElement) ? "attached" : "available";
  }
  function accessibleNameForElement(element, availability = "available") {
    const labelledBy = element.getAttribute("aria-labelledby")?.split(/\s+/).map((id) => {
      const labelledElement = element.ownerDocument?.getElementById(id);
      if (!labelledElement) return "";
      return accessibleTextContent(
        labelledElement,
        labelledElement === element ? void 0 : element,
        referencedLabelAvailability(labelledElement, availability)
      );
    }).join(" ");
    const labels = "labels" in element ? Array.from(element.labels ?? []).map((label) => accessibleTextContent(label, element, availability)).join(" ") : "";
    let inputValue = "";
    if (element instanceof HTMLInputElement && ["button", "submit", "reset"].includes(element.type)) {
      inputValue = element.value;
      if (!element.hasAttribute("value")) {
        if (element.type === "submit") inputValue = "Submit";
        if (element.type === "reset") inputValue = "Reset";
      }
    }
    const explicitRole = explicitRoleForElement(element);
    const contentIsValue = element instanceof HTMLTextAreaElement || element instanceof HTMLSelectElement || isContentEditableRoot(element) && inferNativeFormControlRole(element) === "textbox" || ["textbox", "combobox", "listbox"].includes(explicitRole ?? "");
    const contentCanName = ROLE_NAME_FROM_CONTENT.has(explicitRole ?? inferRoleForElement(element)) || !explicitRole && NATIVE_NAME_FROM_CONTENT_TAGS.has(element.tagName);
    const svgTitle = element instanceof SVGElement && ["image", "img"].includes(explicitRole ?? inferRoleForElement(element)) ? Array.from(element.children).map((child) => accessibleTitleText(child, availability === "attached")).find(Boolean) : "";
    const alt = element instanceof HTMLImageElement || element instanceof HTMLAreaElement || element instanceof HTMLInputElement && element.type === "image" ? element.getAttribute("alt") : "";
    return [
      labelledBy,
      element.getAttribute("aria-label"),
      labels,
      alt,
      svgTitle,
      inputValue,
      !contentIsValue && contentCanName ? contentName(element, availability) : "",
      element.getAttribute("title"),
      element.getAttribute("placeholder")
    ].map(normalizeWhitespace).find((candidate) => candidate !== "") ?? "";
  }

  // src/builder-bridge/preview-lens/utils/element-locator.ts
  var TEXT_PSEUDO_RE = /:(?:has-text|contains|text)\(\s*(['"]?)([\s\S]*?)\1\s*\)\s*$/i;
  var TEXT_ENGINE_RE = /^text\s*\*?=\s*(['"]?)([\s\S]*?)\1$/i;
  var DOCUMENT_WRAPPER_TAGS = /* @__PURE__ */ new Set(["body", "head", "html"]);
  function normalizeLocatorText(text) {
    return text.replace(/\s+/g, " ").trim().toLowerCase();
  }
  function textPseudoScope(rawPrefix) {
    const trimmed = rawPrefix.trim();
    if (trimmed === "" || trimmed === "*") return "body *";
    if (/[\s>+~]$/.test(rawPrefix)) return `${trimmed} *`;
    return trimmed;
  }
  function elementMatchesAvailability(element, availability, modalDialog) {
    if (availability === "attached") return true;
    if (availability === "visible" || availability === "click" || availability === "fill") {
      return !isElementOrAncestorHidden(element);
    }
    return !isElementOrAncestorUnavailable(element, modalDialog);
  }
  function textAvailability(availability) {
    return availability === "visible" || availability === "click" || availability === "fill" ? "interaction" : availability;
  }
  function actionableCandidatesFirst(candidates, availability) {
    const unavailableReason = availability === "click" ? clickUnavailableReason : availability === "fill" ? fillUnavailableReason : null;
    if (!unavailableReason) return candidates;
    const actionable = candidates.filter((element) => unavailableReason(element) === null);
    const blocked = candidates.filter((element) => unavailableReason(element) !== null);
    return [...actionable, ...blocked];
  }
  function locatorText(element, availability) {
    if (availability === "attached") {
      return isCollapsedSelectOption(element) ? element.textContent ?? "" : accessibleTextContent(element, void 0, "attached");
    }
    return visibleTextContent(element, textAvailability(availability));
  }
  function innermostTextMatch(scope, text, options = {}) {
    const needle = normalizeLocatorText(text);
    if (!needle) throw new Error("text locator requires non-empty text");
    const availability = options.availability ?? "available";
    const modalDialog = activeModalDialog(document);
    const matches = Array.from(document.querySelectorAll(scope)).flatMap((element) => {
      if (DOCUMENT_WRAPPER_TAGS.has(element.localName) || isNonRenderedContentElement(element) || !elementMatchesAvailability(element, availability, modalDialog)) return [];
      const candidateText = normalizeLocatorText(locatorText(element, availability));
      const exact = candidateText === needle;
      return candidateText.includes(needle) && (!options.exactOnly || exact) ? [{ element, exact }] : [];
    });
    const preferred = options.exactOnly || matches.some(({ exact }) => exact) ? matches.filter(({ exact }) => exact).map(({ element }) => element) : matches.map(({ element }) => element);
    const ordered = actionableCandidatesFirst(preferred, availability);
    return firstInnermost(ordered);
  }
  function firstInnermost(matches) {
    const matchSet = new Set(matches);
    const matchingAncestors = /* @__PURE__ */ new Set();
    for (const match of matches) {
      for (let ancestor = match.parentElement; ancestor; ancestor = ancestor.parentElement) {
        if (matchSet.has(ancestor)) matchingAncestors.add(ancestor);
      }
    }
    return matches.find((element) => !matchingAncestors.has(element)) ?? null;
  }
  function queryCssOrTextPseudo(selector, options = {}) {
    const engineMatch = TEXT_ENGINE_RE.exec(selector.trim());
    const pseudoMatch = engineMatch ?? TEXT_PSEUDO_RE.exec(selector);
    if (!pseudoMatch) {
      const candidates = Array.from(document.querySelectorAll(selector));
      if (options.availability !== "visible" && options.availability !== "click" && options.availability !== "fill") {
        return candidates[0] ?? null;
      }
      const visibleCandidates = candidates.filter((element) => !isElementOrAncestorHidden(element));
      if (options.availability === "visible") return visibleCandidates[0] ?? null;
      return actionableCandidatesFirst(visibleCandidates, options.availability)[0] ?? null;
    }
    const prefix = engineMatch ? "" : selector.slice(0, pseudoMatch.index);
    return innermostTextMatch(textPseudoScope(prefix), pseudoMatch[2], options);
  }
  function queryByRole(role, name, options = {}) {
    const normalizedRole = role.trim().toLowerCase();
    const normalizedName = name === void 0 ? void 0 : normalizeLocatorText(name);
    const availability = options.availability ?? "available";
    const modalDialog = activeModalDialog(document);
    const candidates = Array.from(document.querySelectorAll(selectorForRole(normalizedRole))).filter((element) => !DOCUMENT_WRAPPER_TAGS.has(element.localName) && !isNonRenderedContentElement(element) && elementMatchesAvailability(element, availability, modalDialog) && (availability === "attached" || !isCollapsedSelectOption(element)) && elementHasRole(element, normalizedRole));
    const orderedCandidates = actionableCandidatesFirst(candidates, availability);
    if (normalizedName === void 0) return orderedCandidates[0] ?? null;
    let substringMatch = null;
    for (const element of orderedCandidates) {
      const candidateName = normalizeLocatorText(accessibleNameForElement(element, textAvailability(availability)));
      if (candidateName === normalizedName) return element;
      if (!substringMatch && candidateName.includes(normalizedName)) substringMatch = element;
    }
    return options.exactOnly ? null : substringMatch;
  }
  function queryByText(text, options = {}) {
    return innermostTextMatch("body *", text, options);
  }
  function queryByTestId(testId, options = {}) {
    const availability = options.availability ?? "available";
    const modalDialog = activeModalDialog(document);
    const candidates = Array.from(document.querySelectorAll("[data-testid]")).filter((element) => element.getAttribute("data-testid") === testId && elementMatchesAvailability(element, availability, modalDialog));
    return actionableCandidatesFirst(candidates, availability)[0] ?? null;
  }

  // src/builder-bridge/preview-lens/utils/element-target.ts
  var ElementTargetError = class extends Error {
    constructor(reason, message) {
      super(message);
      this.reason = reason;
      this.name = "ElementTargetError";
    }
  };
  var PLAYWRIGHT_SYNTAX_RE = /:(?:has-text|contains|text)\(|^text\s*\*?=|:visible\b/i;
  function requireString(record2, key) {
    const value = record2[key];
    if (typeof value !== "string" || !value.trim()) {
      const reason = `empty_${key === "testId" ? "test_id" : key}`;
      const correction = key === "name" ? "provide a non-empty accessible name or omit name" : `provide a non-empty ${key} string; guard dynamic values before constructing the locator`;
      throw new ElementTargetError(reason, correction);
    }
    return value;
  }
  function createElementLocator(rawTarget) {
    if (typeof rawTarget === "string") {
      if (!rawTarget.trim()) {
        throw new ElementTargetError("empty_selector", "provide a non-empty CSS selector or a structured locator");
      }
      return {
        label: rawTarget,
        query: (options) => queryCssOrTextPseudo(rawTarget, options)
      };
    }
    if (!rawTarget || typeof rawTarget !== "object" || Array.isArray(rawTarget)) {
      throw new ElementTargetError(
        "invalid_target_shape",
        "pass CSS, {css}, {text}, {role, name?}, {testId}, or a DOM Element directly"
      );
    }
    const record2 = rawTarget;
    const keys = Object.keys(record2);
    const locatorKeys = keys.filter((key2) => ["css", "text", "role", "testId"].includes(key2));
    if (locatorKeys.length > 1) {
      throw new ElementTargetError(
        "multiple_locator_keys",
        "use exactly one locator key: css, text, role, or testId"
      );
    }
    if ("role" in record2) {
      if (keys.some((key2) => key2 !== "role" && key2 !== "name")) {
        throw new ElementTargetError(
          "role_extra_keys",
          "role locators accept only role and optional name; remove Playwright options such as exact"
        );
      }
      const role = requireString(record2, "role").trim().toLowerCase();
      if (!/^[a-z][a-z0-9-]*$/.test(role)) {
        throw new ElementTargetError("invalid_role", "use a valid ARIA role such as button or textbox");
      }
      const name = "name" in record2 ? requireString(record2, "name") : void 0;
      return {
        label: `role=${role}${name ? `[name="${name}"]` : ""}`,
        query: (options) => queryByRole(role, name, options),
        preferExact: name !== void 0
      };
    }
    if (keys.length !== 1 || !["css", "text", "testId"].includes(keys[0])) {
      throw new ElementTargetError(
        "invalid_target_shape",
        "pass exactly one locator: {css}, {text}, {role, name?}, or {testId}"
      );
    }
    const key = keys[0];
    const value = requireString(record2, key);
    if (key === "css") {
      return {
        label: value,
        query: (options) => queryCssOrTextPseudo(value, options)
      };
    }
    if (key === "text") {
      return {
        label: `text="${value}"`,
        query: (options) => queryByText(value, options),
        preferExact: true
      };
    }
    return { label: `testId="${value}"`, query: (options) => queryByTestId(value, options) };
  }

  // src/builder-bridge/preview-lens/utils/wait-for-element.ts
  function invalidElementTargetResult(rawSelector, selectorError) {
    const reason = selectorError instanceof ElementTargetError ? selectorError.reason : "invalid_css";
    return {
      success: false,
      error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.AGENT_CODE_ERROR,
      data: {
        message: invalidSelectorMessage(rawSelector, selectorError),
        element_target_error_reason: reason
      }
    };
  }
  async function resolveElementTarget(rawSelector, options = {}) {
    if (rawSelector instanceof Element) {
      return {
        element: rawSelector.isConnected ? rawSelector : null,
        selectorLabel: describeElement2(rawSelector)
      };
    }
    try {
      const locator = createElementLocator(rawSelector);
      return {
        element: await waitForLocator(
          locator,
          options.timeoutMs ?? ELEMENT_WAIT_TIMEOUT_MS,
          options.availability ?? "available",
          options.shouldStop
        ),
        selectorLabel: locator.label
      };
    } catch (selectorParseError) {
      return { failure: invalidElementTargetResult(rawSelector, selectorParseError) };
    }
  }
  function describeElement2(element) {
    const id = element.id ? `#${element.id}` : "";
    const classes = typeof element.getAttribute("class") === "string" ? element.getAttribute("class").trim().split(/\s+/).slice(0, 3).map((c) => `.${c}`).join("") : "";
    return `<${element.tagName.toLowerCase()}${id}${classes}>`;
  }
  function invalidSelectorMessage(selector, selectorParseError) {
    const base = `invalid element target: ${selectorParseError instanceof Error ? selectorParseError.message : String(selectorParseError)}`;
    if (typeof selector === "string" && PLAYWRIGHT_SYNTAX_RE.test(selector)) {
      return `${base} \u2014 Playwright selector syntax is not CSS. Use a standard CSS selector, a structured {text}, {role, name}, or {testId} locator.`;
    }
    return base;
  }
  async function waitForLocator(locator, timeoutMs, availability = "available", shouldStop) {
    const deadline = performance.now() + timeoutMs;
    while (true) {
      if (shouldStop?.()) return null;
      const found = locator.query({
        exactOnly: locator.preferExact,
        availability
      });
      if (found) return found;
      if (performance.now() >= deadline) {
        return locator.preferExact ? locator.query({ availability }) : null;
      }
      await new Promise((resolve2) => {
        setTimeout(resolve2, ELEMENT_WAIT_POLL_INTERVAL_MS);
      });
    }
  }
  async function waitForElement(target, timeoutMs) {
    const locator = createElementLocator(target);
    return waitForLocator(locator, timeoutMs);
  }

  // src/builder-bridge/preview-lens/click.ts
  function buildPointerEvent(type, init2) {
    if (typeof PointerEvent === "function") {
      try {
        return new PointerEvent(type, init2);
      } catch {
      }
    }
    return new MouseEvent(type, init2);
  }
  function activateNativeOption(option) {
    const select = option.closest("select");
    if (!select) {
      option.click();
      return;
    }
    const selectionChanged = !option.selected;
    option.selected = true;
    option.click();
    if (!selectionChanged) return;
    select.dispatchEvent(new Event("input", { bubbles: true }));
    select.dispatchEvent(new Event("change", { bubbles: true }));
  }
  async function dispatchRealisticClickSequence(targetElement) {
    const pointerInit = {
      bubbles: true,
      cancelable: true,
      button: 0,
      buttons: 1,
      pointerId: 1,
      pointerType: "mouse",
      isPrimary: true
    };
    const mouseInit = { bubbles: true, cancelable: true, button: 0, buttons: 1 };
    const mouseUpInit = { bubbles: true, cancelable: true, button: 0, buttons: 0 };
    const pointerUpInit = { ...pointerInit, buttons: 0 };
    targetElement.dispatchEvent(buildPointerEvent("pointerover", pointerInit));
    targetElement.dispatchEvent(buildPointerEvent("pointerenter", { ...pointerInit, bubbles: false }));
    targetElement.dispatchEvent(buildPointerEvent("pointerdown", pointerInit));
    targetElement.dispatchEvent(new MouseEvent("mousedown", mouseInit));
    await new Promise((resolve2) => setTimeout(resolve2, 0));
    targetElement.dispatchEvent(buildPointerEvent("pointerup", pointerUpInit));
    targetElement.dispatchEvent(new MouseEvent("mouseup", mouseUpInit));
    const activationTarget = activationTargetForElement(targetElement);
    if (activationTarget instanceof HTMLOptionElement) {
      activateNativeOption(activationTarget);
    } else if (typeof activationTarget.click === "function") {
      activationTarget.click();
    } else {
      activationTarget.dispatchEvent(new MouseEvent("click", mouseInit));
    }
  }
  function dispatchDoubleClickEvent(targetElement) {
    const dblclickEvent = new MouseEvent("dblclick", { bubbles: true, cancelable: true });
    targetElement.dispatchEvent(dblclickEvent);
  }
  async function executePreviewLensClick(rawArgs) {
    const clickArgs = rawArgs;
    const resolved = await resolveElementTarget(rawArgs.selector, { availability: "click" });
    if (resolved.failure) return resolved.failure;
    const { element: matchedElement, selectorLabel } = resolved;
    if (matchedElement === null) {
      return {
        success: true,
        data: { found: false, selector: selectorLabel, current_url: redactedCurrentHref() }
      };
    }
    const element = describeElement2(matchedElement);
    const unavailable = clickUnavailableReason(matchedElement);
    if (unavailable) {
      return {
        success: true,
        data: {
          found: true,
          performed: false,
          reason: unavailable.reason,
          selector: selectorLabel,
          element,
          message: unavailable.message,
          current_url: redactedCurrentHref()
        }
      };
    }
    try {
      await dispatchRealisticClickSequence(matchedElement);
      if (clickArgs.double_click) {
        dispatchDoubleClickEvent(matchedElement);
      }
      return {
        success: true,
        data: {
          found: true,
          performed: true,
          selector: selectorLabel,
          element,
          double_click: !!clickArgs.double_click,
          current_url_after_click: redactedCurrentHref()
        }
      };
    } catch (clickDispatchError) {
      return {
        success: false,
        error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.BRIDGE_ERROR,
        data: {
          message: clickDispatchError instanceof Error ? clickDispatchError.message : String(clickDispatchError)
        }
      };
    }
  }

  // src/builder-bridge/preview-lens/drag-and-drop.ts
  var DEFAULT_MOVE_STEPS = 8;
  var MAX_MOVE_STEPS = 30;
  var DEFAULT_SETTLE_MS = 150;
  var MAX_SETTLE_MS = 2e3;
  var MOUSE_SENSOR_HANDLE_SELECTOR = [
    "[data-rfd-drag-handle-draggable-id]",
    "[data-rbd-drag-handle-draggable-id]"
  ].join(",");
  var MOUSE_SENSOR_DRAGGABLE_SELECTOR = [
    "[data-rfd-draggable-id]",
    "[data-rbd-draggable-id]"
  ].join(",");
  var MOUSE_SENSOR_MOVE_THRESHOLD_PX = 8;
  async function resolveElement(selector) {
    try {
      return { element: await waitForElement(selector, ELEMENT_WAIT_TIMEOUT_MS) };
    } catch (selectorParseError) {
      return {
        element: null,
        errorMessage: `invalid selector: ${selectorParseError instanceof Error ? selectorParseError.message : String(selectorParseError)}`
      };
    }
  }
  function resolveDragHandle(sourceElement, handleSelector) {
    if (!handleSelector) {
      const mouseSensorHandle = findMouseSensorHandle(sourceElement);
      if (mouseSensorHandle.errorMessage) return mouseSensorHandle;
      return { element: mouseSensorHandle.element ?? sourceElement };
    }
    try {
      return {
        element: sourceElement.querySelector(handleSelector) ?? document.querySelector(handleSelector)
      };
    } catch (selectorParseError) {
      return {
        element: null,
        errorMessage: `invalid handle selector: ${selectorParseError instanceof Error ? selectorParseError.message : String(selectorParseError)}`
      };
    }
  }
  function findMouseSensorHandle(sourceElement) {
    const closestHandle = sourceElement.closest(MOUSE_SENSOR_HANDLE_SELECTOR);
    if (closestHandle) return { element: closestHandle };
    const descendantHandle = sourceElement.querySelector(MOUSE_SENSOR_HANDLE_SELECTOR);
    if (descendantHandle && !sourceElement.matches(MOUSE_SENSOR_DRAGGABLE_SELECTOR)) {
      return {
        element: null,
        errorMessage: "source selector matched a container with drag handles; use a specific draggable selector or handle_selector"
      };
    }
    return { element: descendantHandle };
  }
  function shouldUseMouseSensorDrag(sourceElement, handleElement, hasExplicitHandle) {
    if (hasExplicitHandle) return Boolean(handleElement.closest(MOUSE_SENSOR_HANDLE_SELECTOR));
    return Boolean(
      handleElement.closest(MOUSE_SENSOR_HANDLE_SELECTOR) || sourceElement.matches(MOUSE_SENSOR_DRAGGABLE_SELECTOR)
    );
  }
  function clampInteger(value, fallback, min, max) {
    if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
    return Math.max(min, Math.min(Math.trunc(value), max));
  }
  function readElementCenter(element) {
    const rect = element.getBoundingClientRect();
    return {
      x: Math.round(rect.left + rect.width / 2),
      y: Math.round(rect.top + rect.height / 2)
    };
  }
  function pointBetween(start, end, stepIndex, totalSteps) {
    return pointAtProgress(start, end, stepIndex / totalSteps);
  }
  function pointAtProgress(start, end, progress) {
    return {
      x: Math.round(start.x + (end.x - start.x) * progress),
      y: Math.round(start.y + (end.y - start.y) * progress)
    };
  }
  function distanceBetween(start, end) {
    return Math.hypot(end.x - start.x, end.y - start.y);
  }
  function dispatchMouse(target, type, point, buttons) {
    target.dispatchEvent(new MouseEvent(type, {
      bubbles: true,
      cancelable: true,
      clientX: point.x,
      clientY: point.y,
      screenX: point.x,
      screenY: point.y,
      button: 0,
      buttons
    }));
  }
  function dispatchPointer(target, type, point, buttons) {
    if (typeof PointerEvent !== "function") return;
    target.dispatchEvent(new PointerEvent(type, {
      bubbles: true,
      cancelable: true,
      pointerId: 1,
      pointerType: "mouse",
      isPrimary: true,
      clientX: point.x,
      clientY: point.y,
      screenX: point.x,
      screenY: point.y,
      button: 0,
      buttons
    }));
  }
  function buildDataTransfer() {
    if (typeof DataTransfer === "function") return new DataTransfer();
    const dataByType = /* @__PURE__ */ new Map();
    return {
      dropEffect: "move",
      effectAllowed: "all",
      files: [],
      items: [],
      types: [],
      clearData: (format) => {
        if (format) dataByType.delete(format);
        else dataByType.clear();
      },
      getData: (format) => dataByType.get(format) ?? "",
      setData: (format, data) => {
        dataByType.set(format, data);
      },
      setDragImage: () => {
      }
    };
  }
  function dispatchDrag(target, type, point, dataTransfer) {
    let dragEvent;
    if (typeof DragEvent === "function" && typeof DataTransfer === "function") {
      dragEvent = new DragEvent(type, {
        bubbles: true,
        cancelable: true,
        clientX: point.x,
        clientY: point.y,
        dataTransfer
      });
    } else {
      dragEvent = new MouseEvent(type, {
        bubbles: true,
        cancelable: true,
        clientX: point.x,
        clientY: point.y
      });
      Object.defineProperty(dragEvent, "dataTransfer", { value: dataTransfer });
    }
    target.dispatchEvent(dragEvent);
  }
  function scrollIntoViewIfPossible(element) {
    if (typeof element.scrollIntoView !== "function") return;
    element.scrollIntoView({ block: "center", inline: "center" });
  }
  function waitForSettle(settleMs) {
    if (settleMs <= 0) return Promise.resolve();
    return new Promise((resolve2) => {
      setTimeout(resolve2, settleMs);
    });
  }
  function dispatchMoveStep(point, targetAtPoint) {
    dispatchPointer(targetAtPoint, "pointermove", point, 1);
    dispatchMouse(targetAtPoint, "mousemove", point, 1);
  }
  var FRAME_WAIT_CAP_MS = 50;
  function waitForNextFrame() {
    return new Promise((resolve2) => {
      let settled = false;
      const settle = () => {
        if (settled) return;
        settled = true;
        resolve2();
      };
      if (typeof requestAnimationFrame === "function") {
        requestAnimationFrame(() => settle());
      }
      setTimeout(settle, FRAME_WAIT_CAP_MS);
    });
  }
  function pointPastMouseSensorThreshold(start, end) {
    const distance = distanceBetween(start, end);
    const ratio = Math.min(MOUSE_SENSOR_MOVE_THRESHOLD_PX / distance, 1);
    return pointAtProgress(start, end, ratio);
  }
  async function dispatchMouseSensorDrag(handleElement, startPoint, endPoint, steps) {
    dispatchPointer(handleElement, "pointerdown", startPoint, 1);
    dispatchMouse(handleElement, "mousedown", startPoint, 1);
    await waitForNextFrame();
    const thresholdPoint = pointPastMouseSensorThreshold(startPoint, endPoint);
    dispatchPointer(window, "pointermove", thresholdPoint, 1);
    dispatchMouse(window, "mousemove", thresholdPoint, 1);
    await waitForNextFrame();
    const thresholdProgress = MOUSE_SENSOR_MOVE_THRESHOLD_PX / distanceBetween(startPoint, endPoint);
    for (let step = 1; step <= steps; step += 1) {
      const progress = thresholdProgress + (1 - thresholdProgress) * step / steps;
      const stepPoint = pointAtProgress(startPoint, endPoint, progress);
      dispatchPointer(window, "pointermove", stepPoint, 1);
      dispatchMouse(window, "mousemove", stepPoint, 1);
      await waitForNextFrame();
    }
    dispatchPointer(window, "pointerup", endPoint, 0);
    dispatchMouse(window, "mouseup", endPoint, 0);
    await waitForNextFrame();
  }
  function dispatchNativeDrag(sourceElement, targetElement, handleElement, startPoint, endPoint, steps) {
    const dataTransfer = buildDataTransfer();
    dispatchPointer(handleElement, "pointerdown", startPoint, 1);
    dispatchMouse(handleElement, "mousedown", startPoint, 1);
    dispatchDrag(sourceElement, "dragstart", startPoint, dataTransfer);
    let currentEnteredElement = null;
    for (let step = 1; step <= steps; step += 1) {
      const stepPoint = pointBetween(startPoint, endPoint, step, steps);
      const elementUnderPointer = document.elementFromPoint?.(stepPoint.x, stepPoint.y) ?? targetElement;
      if (elementUnderPointer !== currentEnteredElement) {
        if (currentEnteredElement) {
          dispatchDrag(currentEnteredElement, "dragleave", stepPoint, dataTransfer);
        }
        dispatchDrag(elementUnderPointer, "dragenter", stepPoint, dataTransfer);
        currentEnteredElement = elementUnderPointer;
      }
      dispatchMoveStep(stepPoint, elementUnderPointer);
      dispatchDrag(elementUnderPointer, "dragover", stepPoint, dataTransfer);
    }
    if (currentEnteredElement !== targetElement) {
      if (currentEnteredElement) {
        dispatchDrag(currentEnteredElement, "dragleave", endPoint, dataTransfer);
      }
      dispatchDrag(targetElement, "dragenter", endPoint, dataTransfer);
    }
    dispatchDrag(targetElement, "drop", endPoint, dataTransfer);
    dispatchPointer(targetElement, "pointerup", endPoint, 0);
    dispatchMouse(targetElement, "mouseup", endPoint, 0);
    dispatchDrag(sourceElement, "dragend", endPoint, dataTransfer);
  }
  async function executePreviewLensDragAndDrop(rawArgs) {
    const dragArgs = rawArgs;
    if (typeof dragArgs.source_selector !== "string" || dragArgs.source_selector.length === 0) {
      return {
        success: false,
        error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.AGENT_CODE_ERROR,
        data: { message: "dragAndDrop requires a non-empty source_selector argument" }
      };
    }
    if (typeof dragArgs.target_selector !== "string" || dragArgs.target_selector.length === 0) {
      return {
        success: false,
        error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.AGENT_CODE_ERROR,
        data: { message: "dragAndDrop requires a non-empty target_selector argument" }
      };
    }
    const resolvedSource = await resolveElement(dragArgs.source_selector);
    if (resolvedSource.errorMessage) {
      return {
        success: false,
        error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.AGENT_CODE_ERROR,
        data: { message: resolvedSource.errorMessage }
      };
    }
    const resolvedTarget = await resolveElement(dragArgs.target_selector);
    if (resolvedTarget.errorMessage) {
      return {
        success: false,
        error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.AGENT_CODE_ERROR,
        data: { message: resolvedTarget.errorMessage }
      };
    }
    if (resolvedSource.element === null || resolvedTarget.element === null) {
      return {
        success: true,
        data: {
          found: false,
          source_selector: dragArgs.source_selector,
          target_selector: dragArgs.target_selector,
          missing: resolvedSource.element === null ? "source" : "target",
          current_url: redactedCurrentHref()
        }
      };
    }
    const resolvedHandle = resolveDragHandle(resolvedSource.element, dragArgs.handle_selector);
    if (resolvedHandle.errorMessage) {
      return {
        success: false,
        error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.AGENT_CODE_ERROR,
        data: { message: resolvedHandle.errorMessage }
      };
    }
    if (resolvedHandle.element === null) {
      return {
        success: true,
        data: {
          found: false,
          source_selector: dragArgs.source_selector,
          target_selector: dragArgs.target_selector,
          handle_selector: dragArgs.handle_selector,
          missing: "handle",
          current_url: redactedCurrentHref()
        }
      };
    }
    const steps = clampInteger(dragArgs.steps, DEFAULT_MOVE_STEPS, 1, MAX_MOVE_STEPS);
    const settleMs = clampInteger(dragArgs.settle_ms, DEFAULT_SETTLE_MS, 0, MAX_SETTLE_MS);
    try {
      scrollIntoViewIfPossible(resolvedHandle.element);
      scrollIntoViewIfPossible(resolvedTarget.element);
      const startPoint = readElementCenter(resolvedHandle.element);
      const endPoint = readElementCenter(resolvedTarget.element);
      const dragMode = shouldUseMouseSensorDrag(
        resolvedSource.element,
        resolvedHandle.element,
        typeof dragArgs.handle_selector === "string"
      ) ? "mouse_sensor" : "native_drag";
      if (dragMode === "mouse_sensor") {
        if (distanceBetween(startPoint, endPoint) <= MOUSE_SENSOR_MOVE_THRESHOLD_PX) {
          return {
            success: false,
            error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.BRIDGE_ERROR,
            data: {
              message: "source and target centers are too close to simulate a reliable mouse-sensor drag"
            }
          };
        }
        await dispatchMouseSensorDrag(resolvedHandle.element, startPoint, endPoint, steps);
      } else {
        dispatchNativeDrag(
          resolvedSource.element,
          resolvedTarget.element,
          resolvedHandle.element,
          startPoint,
          endPoint,
          steps
        );
      }
      await waitForSettle(settleMs);
      return {
        success: true,
        data: {
          found: true,
          source_selector: dragArgs.source_selector,
          target_selector: dragArgs.target_selector,
          handle_selector: dragArgs.handle_selector ?? null,
          start_point: startPoint,
          end_point: endPoint,
          steps,
          current_url_after_drag: redactedCurrentHref()
        }
      };
    } catch (dragError) {
      return {
        success: false,
        error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.BRIDGE_ERROR,
        data: { message: dragError instanceof Error ? dragError.message : String(dragError) }
      };
    }
  }

  // src/builder-bridge/preview-lens/dom-snapshot.ts
  var DOM_SNAPSHOT_BYTE_CAP = 15 * 1024;
  function extractDirectTextContent(element) {
    if (isClosedDetails(element)) return void 0;
    const childTextNodes = Array.from(element.childNodes).filter(
      (childNode) => childNode.nodeType === Node.TEXT_NODE
    );
    const concatenatedText = childTextNodes.map((textNode) => (textNode.textContent ?? "").trim()).filter((trimmedText) => trimmedText.length > 0).join(" ");
    return concatenatedText.length > 0 ? concatenatedText : void 0;
  }
  function shouldSkipElementInSnapshot(element) {
    if (isNonRenderedContentElement(element)) return true;
    return isElementUnavailable(element) || isCollapsedSelectOption(element);
  }
  function walkDomToAccessibilityTree(element) {
    if (shouldSkipElementInSnapshot(element)) return null;
    const role = inferRoleForElement(element);
    const accessibleName = accessibleNameForElement(element);
    const directText = extractDirectTextContent(element);
    const childNodes2 = [];
    for (const childElement of Array.from(element.children)) {
      const childAccessibilityNode = walkDomToAccessibilityTree(childElement);
      if (childAccessibilityNode !== null) childNodes2.push(childAccessibilityNode);
    }
    const accessibilityNode = { role };
    if (accessibleName && accessibleName !== directText?.replace(/\s+/g, " ").trim()) {
      accessibilityNode.name = accessibleName;
    }
    if (directText !== void 0) accessibilityNode.text = directText;
    if (childNodes2.length > 0) accessibilityNode.children = childNodes2;
    return accessibilityNode;
  }
  function serializeAndApplyByteCap(accessibilityTree, byteCap) {
    return applyByteCap(JSON.stringify(accessibilityTree), byteCap);
  }
  async function executePreviewLensDomSnapshot() {
    try {
      const documentRoot = activeModalDialog(document) ?? document.body ?? document.documentElement;
      const fullAccessibilityTree = walkDomToAccessibilityTree(documentRoot);
      if (fullAccessibilityTree === null) {
        return {
          success: false,
          error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.BRIDGE_ERROR,
          data: { message: "Document has no walkable root element" }
        };
      }
      const { serialized, wasTruncated, originalByteLength } = serializeAndApplyByteCap(
        fullAccessibilityTree,
        DOM_SNAPSHOT_BYTE_CAP
      );
      return {
        success: true,
        data: {
          snapshot: serialized,
          truncated: wasTruncated,
          raw_bytes: originalByteLength,
          cap_bytes: DOM_SNAPSHOT_BYTE_CAP
        }
      };
    } catch (caughtError) {
      return {
        success: false,
        error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.BRIDGE_ERROR,
        data: { message: caughtError instanceof Error ? caughtError.message : String(caughtError) }
      };
    }
  }

  // src/builder-bridge/preview-lens/fill.ts
  var NON_FILLABLE_INPUT_TYPES = /* @__PURE__ */ new Set([
    "button",
    "checkbox",
    "file",
    "hidden",
    "image",
    "radio",
    "reset",
    "submit"
  ]);
  function setReactCompatibleValue(element, value) {
    const valueDescriptor = Object.getOwnPropertyDescriptor(
      element instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype,
      "value"
    );
    if (valueDescriptor?.set) {
      valueDescriptor.set.call(element, value);
    } else {
      element.value = value;
    }
  }
  function dispatchInputAndChangeEvents(element) {
    element.dispatchEvent(new Event("input", { bubbles: true }));
    element.dispatchEvent(new Event("change", { bubbles: true }));
    element.dispatchEvent(new Event("blur", { bubbles: true }));
  }
  function findSelectOption(selectElement, requestedValue) {
    const matchByValue = Array.from(selectElement.options).find(
      (option) => option.value === requestedValue
    );
    return matchByValue ?? Array.from(selectElement.options).find(
      (option) => option.text === requestedValue
    ) ?? null;
  }
  function fillNotPerformed(reason, selectorLabel, element, message) {
    return {
      success: true,
      data: { found: true, performed: false, reason, selector: selectorLabel, element, message }
    };
  }
  async function executePreviewLensFill(rawArgs) {
    const fillArgs = rawArgs;
    if (typeof fillArgs.value !== "string") {
      return {
        success: false,
        error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.AGENT_CODE_ERROR,
        data: { message: "fill requires a string value argument" }
      };
    }
    const resolved = await resolveElementTarget(rawArgs.selector, { availability: "fill" });
    if (resolved.failure) return resolved.failure;
    const { element: matchedElement, selectorLabel } = resolved;
    if (matchedElement === null) {
      return {
        success: true,
        data: { found: false, selector: selectorLabel, current_url: redactedCurrentHref() }
      };
    }
    const element = describeElement2(matchedElement);
    const unavailable = fillUnavailableReason(matchedElement);
    if (unavailable) {
      return fillNotPerformed(unavailable.reason, selectorLabel, element, unavailable.message);
    }
    if (matchedElement instanceof HTMLSelectElement) {
      const matchedOption = findSelectOption(matchedElement, fillArgs.value);
      if (!matchedOption) {
        return fillNotPerformed(
          "option_not_found",
          selectorLabel,
          element,
          `no <option> matched value or text: ${fillArgs.value}`
        );
      }
      if (matchedOption.disabled || matchedOption.parentElement instanceof HTMLOptGroupElement && matchedOption.parentElement.disabled) {
        return fillNotPerformed("disabled", selectorLabel, element, "matched <option> is disabled");
      }
      matchedElement.value = matchedOption.value;
      dispatchInputAndChangeEvents(matchedElement);
      return {
        success: true,
        data: { found: true, performed: true, selector: selectorLabel, element, value: fillArgs.value }
      };
    }
    if (matchedElement instanceof HTMLInputElement && NON_FILLABLE_INPUT_TYPES.has(matchedElement.type)) {
      return fillNotPerformed(
        "not_fillable",
        selectorLabel,
        element,
        `input type="${matchedElement.type}" is not fillable; use click for activatable controls`
      );
    }
    if (matchedElement instanceof HTMLInputElement || matchedElement instanceof HTMLTextAreaElement) {
      setReactCompatibleValue(matchedElement, fillArgs.value);
      dispatchInputAndChangeEvents(matchedElement);
      return {
        success: true,
        data: { found: true, performed: true, selector: selectorLabel, element, value: fillArgs.value }
      };
    }
    if (isContentEditableRoot(matchedElement)) {
      if (matchedElement.matches("[data-lexical-editor], [data-slate-editor], .ProseMirror, .ql-editor")) {
        return fillNotPerformed(
          "not_fillable",
          selectorLabel,
          element,
          "rich contenteditable editors cannot be filled safely; interact with the editor UI instead"
        );
      }
      matchedElement.textContent = fillArgs.value;
      dispatchInputAndChangeEvents(matchedElement);
      return {
        success: true,
        data: { found: true, performed: true, selector: selectorLabel, element, value: fillArgs.value }
      };
    }
    return fillNotPerformed(
      "not_fillable",
      selectorLabel,
      element,
      `element is not a fillable input/textarea/select/contenteditable (tag: ${matchedElement.tagName.toLowerCase()})`
    );
  }

  // src/builder-bridge/preview-lens/inspect.ts
  var DEFAULT_INSPECTED_STYLE_PROPERTIES = [
    "color",
    "background-color",
    "font-size",
    "font-family",
    "font-weight",
    "padding",
    "margin",
    "border",
    "display",
    "position",
    "width",
    "height",
    "opacity"
  ];
  function readComputedStylesForElement(element, requestedStyleProperties) {
    const computedStyles = window.getComputedStyle(element);
    const collected = {};
    for (const requestedName of requestedStyleProperties) {
      collected[requestedName] = computedStyles.getPropertyValue(camelCaseToKebabCaseStyleName(requestedName)).trim();
    }
    return collected;
  }
  function camelCaseToKebabCaseStyleName(styleName) {
    return styleName.replace(/[A-Z]/g, (upper) => `-${upper.toLowerCase()}`);
  }
  function readBoundingBoxForElement(element) {
    const boundingRect = element.getBoundingClientRect();
    return {
      x: Math.round(boundingRect.x),
      y: Math.round(boundingRect.y),
      width: Math.round(boundingRect.width),
      height: Math.round(boundingRect.height)
    };
  }
  async function executePreviewLensInspect(rawArgs) {
    const inspectArgs = rawArgs;
    const resolved = await resolveElementTarget(rawArgs.selector);
    if (resolved.failure) return resolved.failure;
    const { element: matchedElement, selectorLabel } = resolved;
    if (matchedElement === null) {
      return {
        success: true,
        data: { found: false, selector: selectorLabel, current_url: redactedCurrentHref() }
      };
    }
    const requestedStyleProperties = Array.isArray(inspectArgs.styles) ? inspectArgs.styles : DEFAULT_INSPECTED_STYLE_PROPERTIES;
    return {
      success: true,
      data: {
        found: true,
        selector: selectorLabel,
        element: describeElement2(matchedElement),
        tagName: matchedElement.tagName.toLowerCase(),
        id: matchedElement.id || null,
        // getAttribute('class') is always a plain string|null. element.className
        // is an SVGAnimatedString (not a string) for SVG/icon elements, which
        // fails structured-clone/JSON over postMessage/Redis → preview timeout.
        className: matchedElement.getAttribute("class"),
        textContent: (matchedElement.textContent ?? "").trim().slice(0, 500),
        computedStyles: readComputedStylesForElement(matchedElement, requestedStyleProperties),
        boundingBox: readBoundingBoxForElement(matchedElement)
      }
    };
  }

  // src/builder-bridge/preview-lens/utils/eval-budget.ts
  function remainingEvalWaitMs(readRemainingEvalTime) {
    const remainingEvalTime = readRemainingEvalTime?.();
    return remainingEvalTime === null || remainingEvalTime === void 0 ? null : Math.max(0, remainingEvalTime - EVAL_HELPER_COMPLETION_MARGIN_MS);
  }
  function boundedEvalWaitMs(maximumWaitMs, readRemainingEvalTime) {
    const remainingWaitMs = remainingEvalWaitMs(readRemainingEvalTime);
    return remainingWaitMs === null ? maximumWaitMs : Math.min(maximumWaitMs, remainingWaitMs);
  }
  async function settlesWithinEvalBudget(promise, readRemainingEvalTime) {
    const timeoutMs = remainingEvalWaitMs(readRemainingEvalTime);
    if (timeoutMs === null) {
      await promise;
      return true;
    }
    if (timeoutMs <= 0) return false;
    let completed = false;
    let timeoutId;
    try {
      await Promise.race([
        promise.then(() => {
          completed = true;
        }),
        new Promise((resolve2) => {
          timeoutId = setTimeout(resolve2, timeoutMs);
        })
      ]);
      return completed;
    } finally {
      if (timeoutId !== void 0) clearTimeout(timeoutId);
    }
  }

  // src/builder-bridge/preview-lens/utils/routeReadiness.ts
  function getAppRootElement() {
    return document.getElementById("root") ?? document.getElementById("app") ?? document.querySelector("[data-react-root]");
  }
  function isAppRootRendered() {
    const root2 = getAppRootElement();
    return root2 !== null && root2.childElementCount > 0;
  }
  function hasViteErrorOverlay() {
    return document.querySelector("vite-error-overlay") !== null;
  }
  function waitForAnimationFrames(count) {
    return new Promise((resolve2) => {
      let remaining = Math.max(1, count);
      const tick = () => {
        remaining -= 1;
        if (remaining <= 0) resolve2();
        else requestAnimationFrame(tick);
      };
      requestAnimationFrame(tick);
    });
  }
  function waitForRenderSettle(frameCount) {
    return Promise.race([
      waitForAnimationFrames(frameCount),
      new Promise((resolve2) => {
        setTimeout(resolve2, RENDER_SETTLE_FALLBACK_MS);
      })
    ]);
  }
  async function waitForCondition(predicate, timeoutMs) {
    const deadline = Date.now() + timeoutMs;
    while (!predicate()) {
      if (Date.now() >= deadline) return false;
      await new Promise((resolve2) => {
        setTimeout(resolve2, ELEMENT_WAIT_POLL_INTERVAL_MS);
      });
    }
    return true;
  }
  function observeRootRerender(timeoutMs) {
    let isDone = false;
    let observer = null;
    let timeoutId = null;
    let resolveSettled = null;
    const settled = new Promise((resolve2) => {
      resolveSettled = resolve2;
    });
    const finish = (value) => {
      if (isDone) return;
      isDone = true;
      if (observer) observer.disconnect();
      if (timeoutId !== null) clearTimeout(timeoutId);
      resolveSettled?.(value);
    };
    let sawRenderedMutation = false;
    const confirmIfRendered = () => {
      if (isAppRootRendered()) {
        sawRenderedMutation = true;
        void waitForRenderSettle(2).then(() => finish(true));
      }
    };
    observer = new MutationObserver(confirmIfRendered);
    observer.observe(getAppRootElement() ?? document.body, { childList: true, subtree: true });
    timeoutId = setTimeout(() => finish(sawRenderedMutation), timeoutMs);
    return { settled, cancel: () => finish(false) };
  }
  function locationMatchesTarget(requestedPath) {
    try {
      const target = new URL(requestedPath, window.location.origin);
      return target.origin === window.location.origin && window.location.pathname === target.pathname && window.location.search === target.search && window.location.hash === target.hash;
    } catch {
      return false;
    }
  }
  function isSameRouteQueryOnlyTarget(requestedPath) {
    try {
      const target = new URL(requestedPath, window.location.origin);
      return target.origin === window.location.origin && window.location.pathname === target.pathname && window.location.hash === target.hash && window.location.search !== target.search;
    } catch {
      return false;
    }
  }

  // src/builder-bridge/preview-lens/utils/routeRenderTrust.ts
  function currentRelativeUrl() {
    return window.location.pathname + window.location.search + window.location.hash;
  }
  var confirmedRenderedUrl = currentRelativeUrl();
  var pendingRender = null;
  var renderConfirmedListener = null;
  var routeChangeEpoch = 0;
  var invalidatedRouteChangeEpoch = null;
  function noteRouteChangePending(url, settled) {
    routeChangeEpoch += 1;
    invalidatedRouteChangeEpoch = null;
    confirmedRenderedUrl = null;
    pendingRender = { url, settled };
  }
  function getRouteChangeEpoch() {
    return routeChangeEpoch;
  }
  function hasNoRouteDetourSince(startingRouteChangeEpoch) {
    return routeChangeEpoch - startingRouteChangeEpoch <= 1;
  }
  function invalidateCurrentRouteRenderTrust() {
    confirmedRenderedUrl = null;
    pendingRender = null;
    invalidatedRouteChangeEpoch = routeChangeEpoch;
  }
  function noteRouteRenderConfirmed(url) {
    if (invalidatedRouteChangeEpoch === routeChangeEpoch) return;
    if (pendingRender?.url === url) pendingRender = null;
    if (confirmedRenderedUrl === url) return;
    confirmedRenderedUrl = url;
    renderConfirmedListener?.(url);
  }
  function isCurrentUrlRenderConfirmed() {
    return confirmedRenderedUrl === currentRelativeUrl();
  }
  function getPendingRenderConfirmation(url) {
    return pendingRender?.url === url ? pendingRender.settled : null;
  }
  async function waitForLatestRenderConfirmation(readRemainingEvalTime) {
    while (true) {
      const routeChangeEpoch2 = getRouteChangeEpoch();
      const activeRender = pendingRender?.url === currentRelativeUrl() ? pendingRender : null;
      if (!activeRender) return;
      if (!await settlesWithinEvalBudget(activeRender.settled, readRemainingEvalTime)) return;
      if (!await settlesWithinEvalBudget(waitForRenderSettle(2), readRemainingEvalTime)) return;
      if (getRouteChangeEpoch() === routeChangeEpoch2) return;
    }
  }
  function setRenderConfirmedListener(listener) {
    renderConfirmedListener = listener;
  }

  // src/builder-bridge/preview-lens/utils/navigationResult.ts
  function collectRenderFailureEvidence() {
    let recentConsoleErrorCount = 0;
    try {
      recentConsoleErrorCount = extractDebugSnapshot().console.filter((entry) => entry.level === "error").length;
    } catch {
    }
    return {
      root_child_count: getAppRootElement()?.childElementCount ?? null,
      document_hidden: document.hidden,
      viewport: { width: window.innerWidth, height: window.innerHeight },
      recent_console_error_count: recentConsoleErrorCount
    };
  }
  function appRootContentFingerprint() {
    const root2 = getAppRootElement();
    if (!root2) return "no-root";
    const text = root2.textContent ?? "";
    return `${root2.childElementCount}:${text.length}:${text.slice(0, 256)}`;
  }
  function buildNavigationSuccess(requestedPath, mode, extra) {
    return {
      success: true,
      data: {
        // The pathname that ACTUALLY rendered — exposed so a script
        // validating result.path sees reality, not just the requested arg.
        path: window.location.pathname,
        requested_path: requestedPath,
        mode,
        current_url_after_navigate: redactedCurrentHref(),
        ...extra
      }
    };
  }
  function buildNavigationMatchTimeoutFailure(requestedPath) {
    return {
      success: false,
      error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.NAVIGATION_FAILED,
      data: {
        reason: "timeout_waiting_for_navigation",
        message: `navigation to ${requestedPath} did not take effect`,
        requested_path: requestedPath,
        path: window.location.pathname,
        current_url_after_navigate: redactedCurrentHref()
      }
    };
  }
  function buildUrlChangedDuringRenderWaitFailure(requestedPath) {
    return {
      success: false,
      error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.NAVIGATION_FAILED,
      data: {
        reason: "url_changed_during_render_wait",
        message: `the app navigated away to ${window.location.pathname} while confirming ${requestedPath} \u2014 verify the URL the app actually landed on instead`,
        requested_path: requestedPath,
        path: window.location.pathname,
        current_url_after_navigate: redactedCurrentHref()
      }
    };
  }
  function buildRenderConfirmFailure(preNavigationFingerprint, options) {
    const evidence = collectRenderFailureEvidence();
    const rootIsEmpty = evidence.root_child_count === 0;
    const rootContentChanged = appRootContentFingerprint() !== preNavigationFingerprint;
    const reason = rootIsEmpty ? "route_rendered_nothing" : rootContentChanged ? "timeout_waiting_for_render" : "route_content_unchanged";
    const unchangedMessage = options.urlMatchedBeforeNavigation ? `the URL already pointed at ${window.location.pathname} but the displayed content is not a confirmed render of that route \u2014 an earlier navigation moved the URL here without rendering (dead route or unrendered redirect). The PREVIOUS page is still showing; do not verify against it.` : `URL changed to ${window.location.pathname} but the page content did not change \u2014 the route likely did not render (missing route, or the router did not react to the navigation). The PREVIOUS page is still showing; do not verify against it.`;
    const message = rootIsEmpty ? `navigated to ${window.location.pathname} but the app rendered nothing \u2014 #root is empty (likely a runtime crash or error boundary \u2014 pull errors via window.__base44_preview.consoleLogs({level: 'error'}))` : rootContentChanged ? `navigated to ${window.location.pathname} but a route render could not be confirmed. Page content DID change \u2014 if the app looks intact, verify a route-specific element with a DOM query before trusting this page.` : unchangedMessage;
    return {
      success: false,
      error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.NAVIGATION_FAILED,
      data: {
        reason,
        message,
        root_content_changed: rootContentChanged,
        ...options.urlMatchedBeforeNavigation ? { url_matched_before_navigation: true } : {},
        path: window.location.pathname,
        current_url_after_navigate: redactedCurrentHref(),
        ...evidence
      }
    };
  }

  // src/builder-bridge/preview-lens/utils/linkFallback.ts
  function sameOriginTargetUrl(path) {
    try {
      const target = new URL(path, window.location.origin);
      return target.origin === window.location.origin ? target : null;
    } catch {
      return null;
    }
  }
  function findSameOriginAnchorForPath(path) {
    const target = sameOriginTargetUrl(path);
    if (!target) return null;
    const anchors = Array.from(document.querySelectorAll("a[href]"));
    return anchors.find((anchor) => {
      const href = anchor.getAttribute("href");
      if (!href) return false;
      try {
        const anchorUrl = new URL(href, window.location.origin);
        return anchorUrl.origin === window.location.origin && anchorUrl.pathname === target.pathname && anchorUrl.search === target.search && anchorUrl.hash === target.hash;
      } catch {
        return false;
      }
    }) ?? null;
  }
  async function tryLinkNavigationFallback(path, readRemainingEvalTime) {
    const anchor = findSameOriginAnchorForPath(path);
    if (!anchor) return false;
    const renderWaitMs = boundedEvalWaitMs(LINK_FALLBACK_RENDER_TIMEOUT_MS, readRemainingEvalTime);
    if (renderWaitMs <= 0) return false;
    const rootRerender = observeRootRerender(renderWaitMs);
    const startingRouteChangeEpoch = getRouteChangeEpoch();
    anchor.click();
    const navigated = await waitForCondition(
      () => locationMatchesTarget(path),
      boundedEvalWaitMs(NAVIGATION_MATCH_TIMEOUT_MS, readRemainingEvalTime)
    );
    if (!navigated) {
      rootRerender.cancel();
      return false;
    }
    const rendered = await rootRerender.settled;
    const landedOnTarget = locationMatchesTarget(path);
    const routeStayedDirect = hasNoRouteDetourSince(startingRouteChangeEpoch);
    if (landedOnTarget && !routeStayedDirect) invalidateCurrentRouteRenderTrust();
    return rendered && landedOnTarget && routeStayedDirect;
  }

  // src/builder-bridge/preview-lens/navigate.ts
  function performSpaNavigation(path) {
    window.history.pushState({}, "", path);
    window.dispatchEvent(new PopStateEvent("popstate"));
  }
  function routeRemainedStable(path, routeChangeEpoch2) {
    return locationMatchesTarget(path) && getRouteChangeEpoch() === routeChangeEpoch2;
  }
  function navigationLandedWithoutDetour(path, startingRouteChangeEpoch) {
    return locationMatchesTarget(path) && hasNoRouteDetourSince(startingRouteChangeEpoch);
  }
  function invalidateMatchingAmbiguousLanding(path) {
    if (locationMatchesTarget(path)) invalidateCurrentRouteRenderTrust();
  }
  async function confirmAlreadyDisplayedRoute(path, readRemainingEvalTime) {
    if (isCurrentUrlRenderConfirmed() && isAppRootRendered() && !hasViteErrorOverlay()) {
      return buildNavigationSuccess(path, "spa", { already_displayed: true });
    }
    const startingRouteChangeEpoch = getRouteChangeEpoch();
    const rootRerender = observeRootRerender(
      boundedEvalWaitMs(ROUTE_RENDER_TIMEOUT_MS, readRemainingEvalTime)
    );
    window.dispatchEvent(new PopStateEvent("popstate", { state: window.history.state }));
    await settlesWithinEvalBudget(waitForRenderSettle(1), readRemainingEvalTime);
    const preNavigationFingerprint = appRootContentFingerprint();
    const pendingConfirmation = getPendingRenderConfirmation(currentRelativeUrl());
    let rendered = pendingConfirmation ? await Promise.race([pendingConfirmation, rootRerender.settled]) : false;
    if (rendered) rootRerender.cancel();
    else rendered = await rootRerender.settled;
    if (!routeRemainedStable(path, startingRouteChangeEpoch)) {
      invalidateMatchingAmbiguousLanding(path);
      return buildUrlChangedDuringRenderWaitFailure(path);
    }
    if (!rendered) rendered = await tryLinkNavigationFallback(path, readRemainingEvalTime);
    if (!rendered) {
      return buildRenderConfirmFailure(preNavigationFingerprint, { urlMatchedBeforeNavigation: true });
    }
    noteRouteRenderConfirmed(currentRelativeUrl());
    return buildNavigationSuccess(path, "spa");
  }
  async function navigateSameRouteQueryChange(path, readRemainingEvalTime) {
    if (!isCurrentUrlRenderConfirmed() || !isAppRootRendered() || hasViteErrorOverlay()) return null;
    const preNavigationFingerprint = appRootContentFingerprint();
    const rootRerender = observeRootRerender(
      boundedEvalWaitMs(SAME_ROUTE_QUERY_RENDER_WAIT_MS, readRemainingEvalTime)
    );
    const startingRouteChangeEpoch = getRouteChangeEpoch();
    performSpaNavigation(path);
    const navigated = await waitForCondition(
      () => locationMatchesTarget(path),
      boundedEvalWaitMs(NAVIGATION_MATCH_TIMEOUT_MS, readRemainingEvalTime)
    );
    if (!navigated) {
      rootRerender.cancel();
      return buildNavigationMatchTimeoutFailure(path);
    }
    const renderMutationObserved = await rootRerender.settled;
    if (!navigationLandedWithoutDetour(path, startingRouteChangeEpoch)) {
      invalidateMatchingAmbiguousLanding(path);
      return buildUrlChangedDuringRenderWaitFailure(path);
    }
    if (!isAppRootRendered()) {
      return buildRenderConfirmFailure(preNavigationFingerprint, { urlMatchedBeforeNavigation: false });
    }
    noteRouteRenderConfirmed(currentRelativeUrl());
    return buildNavigationSuccess(path, "spa", {
      same_route_query_change: true,
      render_mutation_observed: renderMutationObserved
    });
  }
  async function executePreviewLensNavigate(rawArgs, readRemainingEvalTime) {
    const navigateArgs = rawArgs;
    if (typeof navigateArgs.path !== "string" || navigateArgs.path.length === 0) {
      return {
        success: false,
        error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.AGENT_CODE_ERROR,
        data: { message: "navigate requires a non-empty path argument" }
      };
    }
    try {
      if (navigateArgs.full_reload) {
        window.location.assign(navigateArgs.path);
        return {
          success: true,
          data: {
            path: navigateArgs.path,
            mode: "full_reload",
            note: "Page is reloading; bridge will reinitialize on the new page."
          }
        };
      }
      if (locationMatchesTarget(navigateArgs.path)) {
        return await confirmAlreadyDisplayedRoute(navigateArgs.path, readRemainingEvalTime);
      }
      if (isSameRouteQueryOnlyTarget(navigateArgs.path)) {
        const sameRouteResult = await navigateSameRouteQueryChange(
          navigateArgs.path,
          readRemainingEvalTime
        );
        if (sameRouteResult) return sameRouteResult;
      }
      const preNavigationFingerprint = appRootContentFingerprint();
      const rootRerender = observeRootRerender(
        boundedEvalWaitMs(ROUTE_RENDER_TIMEOUT_MS, readRemainingEvalTime)
      );
      const startingRouteChangeEpoch = getRouteChangeEpoch();
      performSpaNavigation(navigateArgs.path);
      const navigated = await waitForCondition(
        () => locationMatchesTarget(navigateArgs.path),
        boundedEvalWaitMs(NAVIGATION_MATCH_TIMEOUT_MS, readRemainingEvalTime)
      );
      if (!navigated) {
        rootRerender.cancel();
        return buildNavigationMatchTimeoutFailure(navigateArgs.path);
      }
      const rendered = await rootRerender.settled;
      if (!navigationLandedWithoutDetour(navigateArgs.path, startingRouteChangeEpoch)) {
        invalidateMatchingAmbiguousLanding(navigateArgs.path);
        return buildUrlChangedDuringRenderWaitFailure(navigateArgs.path);
      }
      if (!rendered) {
        const renderedViaLinkFallback = await tryLinkNavigationFallback(
          navigateArgs.path,
          readRemainingEvalTime
        );
        if (renderedViaLinkFallback) {
          noteRouteRenderConfirmed(currentRelativeUrl());
          return buildNavigationSuccess(navigateArgs.path, "spa_link_fallback");
        }
        return buildRenderConfirmFailure(preNavigationFingerprint, { urlMatchedBeforeNavigation: false });
      }
      noteRouteRenderConfirmed(currentRelativeUrl());
      return buildNavigationSuccess(navigateArgs.path, "spa");
    } catch (navigationError) {
      return {
        success: false,
        error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.NAVIGATION_FAILED,
        data: {
          message: navigationError instanceof Error ? navigationError.message : String(navigationError)
        }
      };
    }
  }

  // src/builder-bridge/preview-lens/navigate-evidence-validation.ts
  function agentCodeError(message, data) {
    return {
      success: false,
      error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.AGENT_CODE_ERROR,
      data: { message, ...data }
    };
  }
  function resolveNavigatePath(args) {
    if (typeof args.path !== "string" || args.path.length === 0) {
      return agentCodeError("navigateAndConfirm requires a non-empty path argument");
    }
    if (args.full_reload) {
      return agentCodeError(
        "navigateAndConfirm cannot confirm a full reload; use navigate(path, {reload: true})"
      );
    }
    let target;
    try {
      target = new URL(args.path, window.location.href);
    } catch {
      return agentCodeError("navigateAndConfirm requires a valid same-origin path");
    }
    if (target.origin !== window.location.origin) {
      return agentCodeError("navigateAndConfirm only supports same-origin paths");
    }
    if (args.expect instanceof Element) {
      return agentCodeError(
        "navigateAndConfirm expect must be a locator, not a DOM Element from the previous route",
        { element_target_error_reason: "invalid_target_shape" }
      );
    }
    return target.pathname + target.search + target.hash;
  }

  // src/builder-bridge/preview-lens/utils/stable-element-target.ts
  function remainingElementWaitMs(readRemainingEvalTime) {
    return readRemainingEvalTime ? boundedEvalWaitMs(ELEMENT_WAIT_TIMEOUT_MS, readRemainingEvalTime) : void 0;
  }
  async function resolveStableElementTarget(target, readRemainingEvalTime) {
    const startingRouteChangeEpoch = getRouteChangeEpoch();
    const routeChanged = () => getRouteChangeEpoch() !== startingRouteChangeEpoch;
    const result2 = await resolveElementTarget(
      target,
      {
        timeoutMs: remainingElementWaitMs(readRemainingEvalTime),
        shouldStop: routeChanged
      }
    );
    if (result2.failure) return { failure: result2.failure };
    if (routeChanged()) return {};
    return { element: result2.element };
  }

  // src/builder-bridge/preview-lens/navigate-evidence.ts
  function classifyNavigateOutcome(inner, data, landedElsewhere, navigationChanged) {
    const redirectConfirmed = data.reason === "url_changed_during_render_wait" || landedElsewhere && navigationChanged;
    if (redirectConfirmed) {
      return { status: "redirected", renderConfirmed: false };
    }
    if (inner.success) {
      return {
        status: data.already_displayed === true ? "already_rendered" : "rendered",
        renderConfirmed: true
      };
    }
    if (data.reason === "route_rendered_nothing") {
      return { status: "app_broken", renderConfirmed: false };
    }
    return { status: "inconclusive", renderConfirmed: false };
  }
  async function executePreviewLensNavigateAndConfirm(rawArgs, readRemainingEvalTime) {
    const args = rawArgs;
    const resolvedPath = resolveNavigatePath(args);
    if (typeof resolvedPath !== "string") return resolvedPath;
    const expectedTargetValidation = args.expect === void 0 ? void 0 : await resolveElementTarget(args.expect, { timeoutMs: 0 });
    if (expectedTargetValidation?.failure) return expectedTargetValidation.failure;
    const expectedTargetBeforeNavigation = expectedTargetValidation?.element;
    const startingUrl = currentRelativeUrl();
    const startingRouteChangeEpoch = getRouteChangeEpoch();
    const inner = await executePreviewLensNavigate({ path: resolvedPath }, readRemainingEvalTime);
    const data = inner.data ?? {};
    const requested = redactUrlCredentials(resolvedPath);
    const landedElsewhere = !locationMatchesTarget(resolvedPath);
    const navigationChanged = currentRelativeUrl() !== startingUrl || getRouteChangeEpoch() !== startingRouteChangeEpoch;
    let { status, renderConfirmed } = classifyNavigateOutcome(inner, data, landedElsewhere, navigationChanged);
    const landingBeforeExpectation = currentRelativeUrl();
    const routeChangeEpochBeforeExpectation = getRouteChangeEpoch();
    let expectedTargetFound;
    let expectedTargetAfterNavigation;
    if (args.expect !== void 0 && status !== "app_broken" && !landedElsewhere) {
      const expectedAfterNavigation = await resolveStableElementTarget(args.expect, readRemainingEvalTime);
      if (expectedAfterNavigation.failure) return expectedAfterNavigation.failure;
      expectedTargetAfterNavigation = expectedAfterNavigation.element;
      expectedTargetFound = expectedTargetAfterNavigation === void 0 ? void 0 : expectedTargetAfterNavigation !== null;
      if (expectedTargetFound === false && renderConfirmed) {
        renderConfirmed = false;
        status = "inconclusive";
      }
    }
    const landingChangedDuringExpectation = currentRelativeUrl() !== landingBeforeExpectation || getRouteChangeEpoch() !== routeChangeEpochBeforeExpectation;
    if (landingChangedDuringExpectation) {
      status = "redirected";
      renderConfirmed = false;
      expectedTargetFound = void 0;
    }
    const pendingRender2 = getPendingRenderConfirmation(currentRelativeUrl());
    if (pendingRender2) {
      if (status === "redirected") await waitForLatestRenderConfirmation(readRemainingEvalTime);
      else await Promise.race([pendingRender2, waitForRenderSettle(2)]);
    }
    if (args.expect !== void 0 && expectedTargetFound === void 0 && status !== "app_broken" && locationMatchesTarget(resolvedPath)) {
      const expectedAfterBounce = await resolveStableElementTarget(args.expect, readRemainingEvalTime);
      if (expectedAfterBounce.failure) return expectedAfterBounce.failure;
      expectedTargetAfterNavigation = expectedAfterBounce.element;
      expectedTargetFound = expectedTargetAfterNavigation === void 0 ? void 0 : expectedTargetAfterNavigation !== null;
    }
    const freshExpectedTargetFound = args.expect !== void 0 && expectedTargetFound === true && expectedTargetAfterNavigation !== expectedTargetBeforeNavigation;
    const freshRouteNeedsCorroboration = inner.success && data.already_displayed !== true && data.same_route_query_change !== true && !landedElsewhere;
    if (freshRouteNeedsCorroboration && status !== "redirected" && !freshExpectedTargetFound) {
      status = "inconclusive";
      renderConfirmed = false;
      invalidateCurrentRouteRenderTrust();
    }
    const finalLandedElsewhere = !locationMatchesTarget(resolvedPath);
    const finalRouteRendered = isCurrentUrlRenderConfirmed() && isAppRootRendered() && !hasViteErrorOverlay();
    const finalExpectationConfirmed = args.expect === void 0 || expectedTargetFound === true;
    if (finalLandedElsewhere && status === "redirected") {
      status = "redirected";
      renderConfirmed = false;
      expectedTargetFound = void 0;
    } else if (!finalLandedElsewhere && status === "redirected") {
      renderConfirmed = false;
    } else if (renderConfirmed && (!finalRouteRendered || !finalExpectationConfirmed)) {
      status = "inconclusive";
      renderConfirmed = false;
    }
    return {
      success: true,
      data: {
        requested_path: requested,
        landed_path: redactUrlCredentials(currentRelativeUrl()),
        status,
        render_confirmed: renderConfirmed,
        requested_route_verified: renderConfirmed && !finalLandedElsewhere,
        ...status === "redirected" ? { landed_route_rendered: finalRouteRendered } : {},
        ...expectedTargetFound !== void 0 ? { expected_target_found: expectedTargetFound } : {},
        current_url: redactedCurrentHref(),
        ...typeof data.message === "string" ? { detail: redactString(data.message) } : {}
      }
    };
  }

  // src/builder-bridge/preview-lens/utils/pagination.ts
  var DEFAULT_LINE_COUNT = 100;
  var MAX_LINE_COUNT = 500;
  function clampRequestedLineCount(requested) {
    if (typeof requested !== "number" || !Number.isFinite(requested)) return DEFAULT_LINE_COUNT;
    return Math.max(1, Math.min(Math.floor(requested), MAX_LINE_COUNT));
  }

  // src/builder-bridge/preview-lens/network-requests.ts
  function isFailedRequest(networkEntry) {
    if (typeof networkEntry.status !== "number") return true;
    return networkEntry.status >= 400;
  }
  function buildNetworkRequestSummary(networkEntry, indexInBuffer) {
    return {
      request_index: String(indexInBuffer),
      url: redactUrlCredentials(networkEntry.url ?? ""),
      method: networkEntry.method ?? "",
      status: typeof networkEntry.status === "number" ? networkEntry.status : null
    };
  }
  function redactNetworkEntry(networkEntry) {
    const redacted = redactDeep(networkEntry);
    for (const key of Object.keys(redacted)) {
      if (typeof redacted[key] === "string" && /body|payload/i.test(key)) {
        redacted[key] = redactString(redacted[key]);
      }
    }
    if (typeof redacted.url === "string") {
      redacted.url = redactUrlCredentials(redacted.url);
    }
    return redacted;
  }
  async function executePreviewLensNetworkRequests(rawArgs) {
    const networkArgs = rawArgs;
    try {
      const snapshot2 = extractDebugSnapshot();
      const allRequests = snapshot2.network;
      if (typeof networkArgs.request_index === "string") {
        const parsedIndex = parseInt(networkArgs.request_index, 10);
        if (Number.isNaN(parsedIndex) || parsedIndex < 0 || parsedIndex >= allRequests.length) {
          return {
            success: true,
            data: { found: false, request_index: networkArgs.request_index, total_buffered: allRequests.length }
          };
        }
        return { success: true, data: { found: true, request: redactNetworkEntry(allRequests[parsedIndex]) } };
      }
      const indexedRequests = allRequests.map((entry, originalIndex) => ({ entry, originalIndex }));
      const filteredRequests = networkArgs.filter === "failed" ? indexedRequests.filter(({ entry }) => isFailedRequest(entry)) : indexedRequests;
      const lineCountToReturn = clampRequestedLineCount(networkArgs.lines);
      const tailedRequests = filteredRequests.slice(-lineCountToReturn);
      const requestSummaries = tailedRequests.map(
        ({ entry, originalIndex }) => buildNetworkRequestSummary(entry, originalIndex)
      );
      return {
        success: true,
        data: {
          requests: requestSummaries,
          returned_count: requestSummaries.length,
          total_buffered: allRequests.length,
          filter: networkArgs.filter ?? "all"
        }
      };
    } catch (caughtError) {
      return {
        success: false,
        error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.BRIDGE_ERROR,
        data: { message: caughtError instanceof Error ? caughtError.message : String(caughtError) }
      };
    }
  }

  // src/builder-bridge/preview-lens/react-state.ts
  var REACT_STATE_RESULT_BYTE_CAP = 60 * 1024;
  var VALID_MODES = /* @__PURE__ */ new Set(["focused", "full-tree", "target"]);
  var VALID_TARGET_MATCHES = /* @__PURE__ */ new Set(["exact", "startsWith", "includes"]);
  function serializeAndApplyByteCap2(value) {
    return applyByteCap(JSON.stringify(value) ?? "undefined", REACT_STATE_RESULT_BYTE_CAP);
  }
  function parseTargetMatch(value) {
    return typeof value === "string" && VALID_TARGET_MATCHES.has(value) ? value : void 0;
  }
  function parseTarget(rawTarget) {
    if (!rawTarget || typeof rawTarget !== "object") return void 0;
    const target = rawTarget;
    const match = parseTargetMatch(target.match);
    const index2 = typeof target.index === "number" ? target.index : void 0;
    if (target.kind === "last-interaction") return { kind: "last-interaction" };
    if (target.kind === "css-selector" && typeof target.selector === "string") {
      return { kind: "css-selector", selector: target.selector, index: index2 };
    }
    if (target.kind === "source-location" && typeof target.sourceLocation === "string") {
      return { kind: "source-location", sourceLocation: target.sourceLocation, match, index: index2 };
    }
    if (target.kind === "component-name" && typeof target.name === "string") {
      return {
        kind: "component-name",
        name: target.name,
        sourceLocation: typeof target.sourceLocation === "string" ? target.sourceLocation : void 0,
        match,
        index: index2
      };
    }
    return void 0;
  }
  function parseMode(rawMode) {
    if (rawMode === void 0 || rawMode === null) return "full-tree";
    return typeof rawMode === "string" && VALID_MODES.has(rawMode) ? rawMode : null;
  }
  async function executePreviewLensReactState(rawArgs) {
    const reactStateArgs = rawArgs;
    const mode = parseMode(reactStateArgs.mode);
    if (!mode) {
      return {
        success: false,
        error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.AGENT_CODE_ERROR,
        data: { message: "react_state mode must be one of focused, full-tree, or target" }
      };
    }
    const target = parseTarget(reactStateArgs.target);
    if (mode === "target" && !target) {
      return {
        success: false,
        error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.AGENT_CODE_ERROR,
        data: { message: "react_state target mode requires a valid target object" }
      };
    }
    setReactDebugEnabled(true);
    const includeFullTree = mode === "full-tree" || reactStateArgs.include_full_tree === true || reactStateArgs.includeFullTree === true;
    const snapshot2 = collectReactDebugSnapshot({
      reason: "manual",
      includeFullTree,
      target
    });
    if (!snapshot2) {
      return {
        success: false,
        error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.BRIDGE_ERROR,
        data: { message: "React debug snapshot could not be collected" }
      };
    }
    const { serialized, wasTruncated, originalByteLength } = serializeAndApplyByteCap2(snapshot2);
    return {
      success: true,
      data: {
        snapshot: serialized,
        truncated: wasTruncated,
        raw_bytes: originalByteLength,
        cap_bytes: REACT_STATE_RESULT_BYTE_CAP,
        react_detected: snapshot2.reactDetected
      }
    };
  }

  // src/builder-bridge/preview-lens/wait-for.ts
  var WAIT_FOR_STATES = [
    "attached",
    "visible",
    "hidden",
    "enabled",
    "disabled"
  ];
  var DEFAULT_WAIT_TIMEOUT_MS = 5e3;
  function matchesState(element, state) {
    if (state === "hidden") return element === null || isElementOrAncestorHidden(element);
    if (element === null) return false;
    if (state === "attached") return true;
    if (state === "visible") return !isElementOrAncestorHidden(element);
    const unavailable = clickUnavailableReason(element) !== null;
    return state === "disabled" ? unavailable : !unavailable;
  }
  async function executePreviewLensWaitFor(rawArgs) {
    const args = rawArgs;
    const state = args.state ?? "visible";
    if (!WAIT_FOR_STATES.includes(state)) {
      return {
        success: false,
        error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.AGENT_CODE_ERROR,
        data: { message: `invalid waitFor state '${state}' \u2014 use one of: ${WAIT_FOR_STATES.join(", ")}` }
      };
    }
    if (args.timeout_ms !== void 0 && (typeof args.timeout_ms !== "number" || !Number.isFinite(args.timeout_ms) || args.timeout_ms < 0)) {
      return {
        success: false,
        error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.AGENT_CODE_ERROR,
        data: { message: "waitFor timeout must be a finite non-negative number" }
      };
    }
    const timeoutMs = args.timeout_ms ?? DEFAULT_WAIT_TIMEOUT_MS;
    let query;
    let selectorLabel;
    let preferExact = false;
    if (args.selector instanceof Element) {
      const passed = args.selector;
      query = () => passed.isConnected ? passed : null;
      selectorLabel = describeElement2(passed);
    } else {
      try {
        const locator = createElementLocator(args.selector);
        query = locator.query;
        selectorLabel = locator.label;
        preferExact = locator.preferExact === true;
      } catch (selectorParseError) {
        return invalidElementTargetResult(args.selector, selectorParseError);
      }
    }
    const startedAt = performance.now();
    const deadline = startedAt + timeoutMs;
    const result2 = (matched, element) => ({
      success: true,
      data: {
        matched,
        state,
        elapsed_ms: Math.round(performance.now() - startedAt),
        selector: selectorLabel,
        element: element ? describeElement2(element) : null,
        ...matched ? {} : { current_url: redactedCurrentHref() }
      }
    });
    const availability = state === "attached" ? "attached" : state === "enabled" || state === "disabled" ? "click" : "visible";
    const queryElement = (exactOnly) => query({ exactOnly, availability });
    try {
      while (true) {
        let element = queryElement(preferExact);
        if (state === "hidden" && preferExact && element === null) {
          element = queryElement();
        }
        if (matchesState(element, state)) return result2(true, element);
        if (performance.now() >= deadline) {
          const fallbackElement = preferExact ? queryElement() : element;
          return result2(matchesState(fallbackElement, state), fallbackElement);
        }
        await new Promise((resolve2) => {
          setTimeout(resolve2, ELEMENT_WAIT_POLL_INTERVAL_MS);
        });
      }
    } catch (selectorQueryError) {
      return invalidElementTargetResult(args.selector, selectorQueryError);
    }
  }

  // src/builder-bridge/preview-lens/window-namespace.ts
  function unwrapOrThrow(helperName, executorResult) {
    if (executorResult.success) return executorResult.data;
    const errorTag = executorResult.error ?? "unknown_error";
    const errorMessage = executorResult.data && typeof executorResult.data === "object" && "message" in executorResult.data ? String(executorResult.data.message) : "";
    const error = new Error(
      `window.__base44_preview.${helperName} failed: ${errorTag}${errorMessage ? ` \u2014 ${errorMessage}` : ""}`
    );
    const category = executorResult.error ?? PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.BRIDGE_ERROR;
    tagHelperFailure(error, {
      category,
      origin: category === PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.AGENT_CODE_ERROR ? "agent_script" : "bridge",
      data: executorResult.data && typeof executorResult.data === "object" && !Array.isArray(executorResult.data) ? executorResult.data : void 0
    });
    throw error;
  }
  async function runHelper(helperName, executor, evalGeneration = currentEvalGeneration()) {
    const startedAt = performance.now();
    if (evalGeneration !== null) markHelperInFlight(evalGeneration, helperName, startedAt);
    try {
      const executorResult = await executor();
      return unwrapOrThrow(helperName, executorResult);
    } catch (thrownError) {
      if (!readHelperFailure(thrownError)) {
        tagHelperFailure(thrownError, {
          origin: "bridge",
          category: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.BRIDGE_ERROR
        });
      }
      throw thrownError;
    } finally {
      if (evalGeneration !== null && isCurrentEvalGeneration(evalGeneration)) {
        clearHelperInFlight(evalGeneration);
        recordHelperCall(evalGeneration, {
          helper_name: helperName,
          duration_ms: Math.round(performance.now() - startedAt)
        });
      }
    }
  }
  async function navigate(path, options, evalGeneration) {
    return runHelper("navigate", () => executePreviewLensNavigate({
      path,
      full_reload: options?.reload === true
    }), evalGeneration);
  }
  async function navigateAndConfirm(path, options, evalGeneration, remoteRemainingEvalTime) {
    const readRemainingEvalTime = evalGeneration === void 0 ? remoteRemainingEvalTime : () => remainingEvalMs(evalGeneration);
    return runHelper("navigateAndConfirm", () => executePreviewLensNavigateAndConfirm({
      path,
      full_reload: options?.reload === true,
      expect: options?.expect
    }, readRemainingEvalTime), evalGeneration);
  }
  async function click(selector, options, evalGeneration) {
    return runHelper("click", () => executePreviewLensClick({
      selector,
      double_click: options?.doubleClick === true
    }), evalGeneration);
  }
  async function dragAndDrop(sourceSelector, targetSelector, options, evalGeneration) {
    return runHelper("dragAndDrop", () => executePreviewLensDragAndDrop({
      source_selector: sourceSelector,
      target_selector: targetSelector,
      handle_selector: options?.handleSelector,
      steps: options?.steps,
      settle_ms: options?.settleMs
    }), evalGeneration);
  }
  async function fill(selector, value, evalGeneration) {
    return runHelper("fill", () => executePreviewLensFill({ selector, value }), evalGeneration);
  }
  async function waitFor(selector, options, evalGeneration) {
    return runHelper("waitFor", () => {
      const remaining = evalGeneration != null ? remainingEvalMs(evalGeneration) : null;
      const requested = options?.timeout;
      const invalidRequestedTimeout = requested !== void 0 && (!Number.isFinite(requested) || requested < 0);
      const requestedOrDefault = requested ?? DEFAULT_WAIT_TIMEOUT_MS;
      const clamped = invalidRequestedTimeout || remaining === null ? requested : Math.max(0, Math.min(requestedOrDefault, remaining - EVAL_HELPER_COMPLETION_MARGIN_MS));
      return executePreviewLensWaitFor({
        selector,
        state: options?.state,
        timeout_ms: clamped
      });
    }, evalGeneration);
  }
  async function inspect(selector, options, evalGeneration) {
    return runHelper("inspect", () => executePreviewLensInspect({
      selector,
      styles: options?.styles
    }), evalGeneration);
  }
  function parseSnapshotField(data) {
    if (data && typeof data === "object" && typeof data.snapshot === "string") {
      const rawSnapshot = data.snapshot;
      let parsed = rawSnapshot;
      try {
        parsed = JSON.parse(rawSnapshot);
      } catch {
      }
      return { ...data, snapshot: parsed };
    }
    return data;
  }
  async function domSnapshot(evalGeneration) {
    return parseSnapshotField(await runHelper("domSnapshot", () => executePreviewLensDomSnapshot(), evalGeneration));
  }
  async function reactState(selector, options, evalGeneration) {
    return parseSnapshotField(await runHelper("reactState", () => executePreviewLensReactState({
      mode: "target",
      target: { kind: "css-selector", selector },
      include_full_tree: options?.includeFullTree === true
    }), evalGeneration));
  }
  async function getNetworkRequests(options, evalGeneration) {
    return runHelper("getNetworkRequests", () => executePreviewLensNetworkRequests({
      filter: options?.filter ?? "all",
      lines: options?.lines,
      request_index: options?.request_index
    }), evalGeneration);
  }
  async function consoleLogs(options, evalGeneration) {
    return runHelper("consoleLogs", () => executePreviewLensConsoleLogs({
      level: options?.level ?? "all",
      lines: options?.lines
    }), evalGeneration);
  }
  var isNamespaceInstalled = false;
  function buildWindowPreviewNamespace(evalGeneration) {
    const namespace = {
      navigate: (path, options) => navigate(path, options, evalGeneration),
      navigateAndConfirm: (path, options) => navigateAndConfirm(path, options, evalGeneration),
      click: (selector, options) => click(selector, options, evalGeneration),
      dragAndDrop: (sourceSelector, targetSelector, options) => dragAndDrop(
        sourceSelector,
        targetSelector,
        options,
        evalGeneration
      ),
      fill: (selector, value) => fill(selector, value, evalGeneration),
      waitFor: (selector, options) => waitFor(selector, options, evalGeneration),
      inspect: (selector, options) => inspect(selector, options, evalGeneration),
      domSnapshot: () => domSnapshot(evalGeneration),
      reactState: (selector, options) => reactState(selector, options, evalGeneration),
      getNetworkRequests: (options) => getNetworkRequests(options, evalGeneration),
      consoleLogs: (options) => consoleLogs(options, evalGeneration)
    };
    Object.defineProperty(namespace, "__readHelperFailure", {
      value: readHelperFailure,
      enumerable: false
    });
    Object.defineProperty(namespace, "__navigateAndConfirmWithBudget", {
      value: (path, options, readRemainingEvalTime) => navigateAndConfirm(path, options, evalGeneration, readRemainingEvalTime),
      enumerable: false
    });
    Object.defineProperty(namespace, "__elementTargetContractVersion", {
      value: ELEMENT_TARGET_CONTRACT_VERSION,
      enumerable: false
    });
    return namespace;
  }
  function createEvalWindowPreviewNamespace(evalGeneration) {
    return buildWindowPreviewNamespace(evalGeneration);
  }
  function installWindowPreviewNamespace() {
    if (isNamespaceInstalled) return;
    isNamespaceInstalled = true;
    window.__base44_preview = buildWindowPreviewNamespace();
  }
  installWindowPreviewNamespace();

  // src/builder-bridge/preview-lens/eval.ts
  var DEFAULT_EVAL_TIMEOUT_SECONDS = 15;
  var MAX_EVAL_TIMEOUT_SECONDS = 30;
  var MIN_EVAL_TIMEOUT_SECONDS = 1;
  var EVAL_RESULT_BYTE_CAP = 15 * 1024;
  function clampTimeoutSeconds(rawTimeoutSeconds) {
    if (typeof rawTimeoutSeconds !== "number" || !Number.isFinite(rawTimeoutSeconds)) {
      return DEFAULT_EVAL_TIMEOUT_SECONDS;
    }
    return Math.max(
      MIN_EVAL_TIMEOUT_SECONDS,
      Math.min(Math.trunc(rawTimeoutSeconds), MAX_EVAL_TIMEOUT_SECONDS)
    );
  }
  function summarizeDomNode(domNode) {
    return {
      tagName: domNode.tagName,
      id: domNode.id || null,
      className: domNode.className || null
    };
  }
  function buildJsonSanitizingReplacer() {
    const seenObjectReferences = /* @__PURE__ */ new WeakSet();
    return function sanitizingReplacer(_key, value) {
      if (typeof value === "function") return "[Function]";
      if (value instanceof Element) return summarizeDomNode(value);
      if (value instanceof Node) return `[Node: ${value.nodeName}]`;
      if (typeof value === "object" && value !== null) {
        if (seenObjectReferences.has(value)) return "[Circular]";
        seenObjectReferences.add(value);
      }
      return value;
    };
  }
  function serializeAndApplyByteCap3(unserializedValue) {
    const sanitizedSerialization = JSON.stringify(unserializedValue, buildJsonSanitizingReplacer());
    const serializationOrEmpty = sanitizedSerialization ?? "undefined";
    const redactedSerialization = redactString(serializationOrEmpty);
    return applyByteCap(redactedSerialization, EVAL_RESULT_BYTE_CAP);
  }
  function sanitizeHelperFailureData(rawData) {
    if (!rawData) return void 0;
    try {
      const { serialized, wasTruncated } = serializeAndApplyByteCap3(rawData);
      if (wasTruncated) return void 0;
      const parsed = JSON.parse(serialized);
      return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
    } catch {
      return void 0;
    }
  }
  function compilePreviewLensExpression(expression) {
    try {
      return new Function(
        "window",
        "globalThis",
        "self",
        "__base44_preview",
        `"use strict"; return (async () => (${expression}))()`
      );
    } catch (compileError) {
      if (!(compileError instanceof SyntaxError)) {
        throw compileError;
      }
      return new Function(
        "window",
        "globalThis",
        "self",
        "__base44_preview",
        `"use strict"; return (async () => { ${expression} })()`
      );
    }
  }
  function installEvalPreviewNamespace(evalPreviewNamespace) {
    const previousDescriptor = Object.getOwnPropertyDescriptor(window, "__base44_preview");
    Object.defineProperty(window, "__base44_preview", {
      value: evalPreviewNamespace,
      configurable: true,
      writable: true,
      enumerable: false
    });
    return () => {
      if (previousDescriptor) {
        Object.defineProperty(window, "__base44_preview", previousDescriptor);
        return;
      }
      delete window.__base44_preview;
    };
  }
  async function evaluateExpressionWithTimeout(expression, timeoutSeconds, evalGeneration) {
    const evalPreviewNamespace = createEvalWindowPreviewNamespace(evalGeneration);
    const restoreEvalPreviewNamespace = installEvalPreviewNamespace(evalPreviewNamespace);
    const timeoutMilliseconds = timeoutSeconds * 1e3;
    setEvalDeadline(evalGeneration, performance.now() + timeoutMilliseconds);
    const evaluationPromise = new Promise((resolveExpression, rejectExpression) => {
      try {
        const compiledFunction = compilePreviewLensExpression(expression);
        Promise.resolve(
          compiledFunction(window, window, window, evalPreviewNamespace)
        ).then(resolveExpression, rejectExpression);
      } catch (synchronousError) {
        rejectExpression(synchronousError);
      }
    });
    let timeoutHandle;
    const timeoutPromise = new Promise((_resolveNever, rejectOnTimeout) => {
      timeoutHandle = setTimeout(() => {
        rejectOnTimeout(new Error(`eval timed out after ${timeoutMilliseconds}ms`));
      }, timeoutMilliseconds);
    });
    try {
      return await Promise.race([evaluationPromise, timeoutPromise]);
    } finally {
      if (timeoutHandle !== void 0) clearTimeout(timeoutHandle);
      restoreEvalPreviewNamespace();
    }
  }
  async function executePreviewLensEval(rawArgs) {
    const evalArgs = rawArgs;
    if (typeof evalArgs.expression !== "string" || evalArgs.expression.length === 0) {
      return {
        success: false,
        error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.AGENT_CODE_ERROR,
        data: {
          message: "eval requires a non-empty expression argument",
          element_target_contract_version: ELEMENT_TARGET_CONTRACT_VERSION
        }
      };
    }
    const timeoutSeconds = clampTimeoutSeconds(evalArgs.timeout_seconds);
    const evalGeneration = resetHelperCallTelemetry();
    let evaluationResult;
    try {
      evaluationResult = await evaluateExpressionWithTimeout(evalArgs.expression, timeoutSeconds, evalGeneration);
    } catch (caughtError) {
      const errorMessage = caughtError instanceof Error ? caughtError.message : String(caughtError);
      const errorStack = caughtError instanceof Error ? caughtError.stack : void 0;
      const isTimeoutError = errorMessage.includes("timed out");
      const helperFailure = readHelperFailure(caughtError);
      const errorCategory = isTimeoutError ? PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.TIMEOUT : helperFailure?.category ?? PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.AGENT_CODE_ERROR;
      return {
        success: false,
        error: errorCategory,
        // A thrown Error can carry credentials (signed URL, cookie, bearer
        // token in the message/stack). The success path redacts before
        // leaving the iframe; this path must too.
        data: {
          // A failed helper's structured payload (tagged by unwrapOrThrow,
          // WeakMap-backed so evaluated code can't forge it) rides along so
          // its diagnostics (navigate render evidence, selector echoes)
          // reach the backend and agent — after the same sanitize/redact/
          // byte-cap pipeline as a success result. Eval's own keys win.
          ...sanitizeHelperFailureData(helperFailure?.data) ?? {},
          message: redactString(errorMessage),
          stack: typeof errorStack === "string" ? redactString(errorStack) : errorStack,
          // Telemetry (read by the BE for logs/metrics; not surfaced to the agent).
          // A helper failure carries its origin via unwrapOrThrow; anything else
          // (the agent's own throw, or the eval-budget timeout) is agent_script.
          failure_origin: helperFailure?.origin ?? "agent_script",
          js_error_name: caughtError instanceof Error ? caughtError.name : void 0,
          // The OUTER eval budget fired; helper slowness is visible in
          // eval_helper_calls[].duration_ms.
          eval_timeout_kind: isTimeoutError ? "total_budget_exceeded" : void 0,
          eval_helper_calls: drainHelperCallTelemetry(),
          element_target_contract_version: ELEMENT_TARGET_CONTRACT_VERSION
        }
      };
    }
    let serialization;
    try {
      serialization = serializeAndApplyByteCap3(evaluationResult);
    } catch (serializationError) {
      return {
        success: false,
        error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.NOT_SERIALIZABLE,
        data: {
          message: serializationError instanceof Error ? serializationError.message : String(serializationError),
          // Unserializable return value = still the agent's code; drain so helpers that already ran aren't lost.
          failure_origin: "agent_script",
          js_error_name: serializationError instanceof Error ? serializationError.name : void 0,
          eval_helper_calls: drainHelperCallTelemetry(),
          element_target_contract_version: ELEMENT_TARGET_CONTRACT_VERSION
        }
      };
    }
    return {
      success: true,
      data: {
        result: serialization.serialized,
        truncated: serialization.wasTruncated,
        raw_bytes: serialization.originalByteLength,
        cap_bytes: EVAL_RESULT_BYTE_CAP,
        eval_helper_calls: drainHelperCallTelemetry(),
        element_target_contract_version: ELEMENT_TARGET_CONTRACT_VERSION
      }
    };
  }

  // src/builder-bridge/preview-lens/console-logs.utils.ts
  var MAX_MESSAGE_CHARS = 600;
  var EVAL_RESULT_SAFE_BYTE_BUDGET = EVAL_RESULT_BYTE_CAP - 1024;
  var URL_PREFIX_PATTERN = /https?:\/\/[^\s/]+\//g;
  function filterByLevel(consoleEntries, requestedLevel) {
    if (requestedLevel === "error") {
      return consoleEntries.filter((entry) => entry.level === "error");
    }
    if (requestedLevel === "warning") {
      return consoleEntries.filter((entry) => entry.level === "warn");
    }
    return consoleEntries;
  }
  function compactMessageForLLM(rawMessage) {
    const urlStripped = rawMessage.replace(URL_PREFIX_PATTERN, "");
    const redacted = redactString(urlStripped);
    if (redacted.length <= MAX_MESSAGE_CHARS) return redacted;
    return redacted.slice(0, MAX_MESSAGE_CHARS) + "... [truncated]";
  }
  function compactEntriesForLLM(entries) {
    const byKey = /* @__PURE__ */ new Map();
    for (const entry of entries) {
      const compactMessage = compactMessageForLLM(entry.message);
      const dedupeKey = `${entry.level}::${compactMessage}`;
      const existing = byKey.get(dedupeKey);
      if (existing) {
        existing.count = (existing.count ?? 1) + 1;
        existing.timestamp = entry.timestamp;
        continue;
      }
      byKey.set(dedupeKey, {
        level: entry.level,
        message: compactMessage,
        timestamp: entry.timestamp,
        count: 1
      });
    }
    return Array.from(byKey.values()).sort((a, b) => a.timestamp - b.timestamp).map((compactedEntry) => {
      if (compactedEntry.count === 1) {
        const { count: _unusedCount, ...withoutCount } = compactedEntry;
        return withoutCount;
      }
      return compactedEntry;
    });
  }
  function withPayloadBytes(payloadWithoutBytes) {
    let payload = {
      ...payloadWithoutBytes,
      payload_bytes: 0,
      payload_byte_budget: EVAL_RESULT_SAFE_BYTE_BUDGET
    };
    for (let iteration = 0; iteration < 4; iteration += 1) {
      const payloadBytes = utf8ByteLength(JSON.stringify(payload));
      if (payloadBytes === payload.payload_bytes) return payload;
      payload = { ...payload, payload_bytes: payloadBytes };
    }
    return payload;
  }
  function buildConsoleLogsPayload({
    entries,
    rawCount,
    totalBuffered,
    levelFilter,
    droppedOldest
  }) {
    return withPayloadBytes({
      entries,
      returned_count: entries.length,
      raw_count: rawCount,
      total_buffered: totalBuffered,
      level_filter: levelFilter,
      dropped_oldest: droppedOldest
    });
  }
  function fitEntriesToEvalBudget({
    entries,
    rawCount,
    totalBuffered,
    levelFilter
  }) {
    const orderedEntries = [...entries].sort((a, b) => a.timestamp - b.timestamp);
    const buildPayloadAfterDropping = (droppedOldest) => buildConsoleLogsPayload({
      entries: orderedEntries.slice(droppedOldest),
      rawCount,
      totalBuffered,
      levelFilter,
      droppedOldest
    });
    const fullPayload = buildPayloadAfterDropping(0);
    if (fullPayload.payload_bytes <= EVAL_RESULT_SAFE_BYTE_BUDGET) return fullPayload;
    let lowestDropCount = 1;
    let highestDropCount = orderedEntries.length;
    let bestPayload = buildPayloadAfterDropping(highestDropCount);
    while (lowestDropCount <= highestDropCount) {
      const candidateDropCount = Math.floor((lowestDropCount + highestDropCount) / 2);
      const candidatePayload = buildPayloadAfterDropping(candidateDropCount);
      if (candidatePayload.payload_bytes <= EVAL_RESULT_SAFE_BYTE_BUDGET) {
        bestPayload = candidatePayload;
        highestDropCount = candidateDropCount - 1;
      } else {
        lowestDropCount = candidateDropCount + 1;
      }
    }
    return bestPayload;
  }

  // src/builder-bridge/preview-lens/console-logs.ts
  async function executePreviewLensConsoleLogs(rawArgs) {
    const consoleArgs = rawArgs;
    try {
      const snapshot2 = extractDebugSnapshot();
      const filteredByLevel = filterByLevel(snapshot2.console, consoleArgs.level ?? "all");
      const lineCountToReturn = clampRequestedLineCount(consoleArgs.lines);
      const tailedEntries = filteredByLevel.slice(-lineCountToReturn);
      const compactedEntries = compactEntriesForLLM(tailedEntries);
      const levelFilter = consoleArgs.level ?? "all";
      return {
        success: true,
        data: fitEntriesToEvalBudget({
          entries: compactedEntries,
          rawCount: tailedEntries.length,
          totalBuffered: snapshot2.console.length,
          levelFilter
        })
      };
    } catch (caughtError) {
      return {
        success: false,
        error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.BRIDGE_ERROR,
        data: { message: caughtError instanceof Error ? caughtError.message : String(caughtError) }
      };
    }
  }

  // src/builder-bridge/preview-lens/ping.ts
  async function executePreviewLensPing() {
    return { success: true, data: { pong: true } };
  }

  // src/builder-bridge/preview-lens/resize.ts
  var VIEWPORT_PRESETS = {
    mobile: { width: 375, height: 812 },
    tablet: { width: 768, height: 1024 },
    desktop: { width: 1280, height: 800 }
  };
  var PRESET_TO_STORE_DEVICE_MODE = {
    mobile: "phone",
    tablet: "tablet",
    desktop: "desktop"
  };
  var DEFAULT_DEVICE_MODE = "desktop";
  var ALREADY_AT_WIDTH_TOLERANCE_PX = 20;
  function resolveTargetDimensions(resizeArgs) {
    if (resizeArgs.preset && VIEWPORT_PRESETS[resizeArgs.preset]) {
      return VIEWPORT_PRESETS[resizeArgs.preset];
    }
    if (typeof resizeArgs.width === "number" && typeof resizeArgs.height === "number") {
      return { width: resizeArgs.width, height: resizeArgs.height };
    }
    return null;
  }
  function applyViewportMetaForWidth(width) {
    let viewportMetaTag = document.querySelector('meta[name="viewport"]');
    if (!viewportMetaTag) {
      viewportMetaTag = document.createElement("meta");
      viewportMetaTag.setAttribute("name", "viewport");
      document.head.appendChild(viewportMetaTag);
    }
    viewportMetaTag.setAttribute("content", `width=${width}, initial-scale=1.0`);
  }
  function dispatchViewportResizeEvents() {
    window.dispatchEvent(new Event("resize"));
    window.dispatchEvent(new Event("orientationchange"));
  }
  function applyColorSchemeAttribute(colorScheme) {
    document.documentElement.setAttribute("data-color-scheme", colorScheme);
    document.documentElement.style.colorScheme = colorScheme;
  }
  function requestBuilderResizeIframeElement(targetDeviceMode, parentOrigin) {
    if (!window.parent || window.parent === window) return;
    window.parent.postMessage(
      { type: "PREVIEW_LENS_RESIZE_DEVICE_MODE", payload: { mode: targetDeviceMode } },
      parentOrigin
    );
  }
  async function executePreviewLensResize(rawArgs, parentOrigin = "*") {
    const resizeArgs = rawArgs;
    const targetDimensions = resolveTargetDimensions(resizeArgs);
    const targetColorScheme = resizeArgs.color_scheme;
    if (targetDimensions === null && !targetColorScheme) {
      return {
        success: false,
        error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.BRIDGE_ERROR,
        data: {
          message: "resize requires either preset, both width+height, or color_scheme"
        }
      };
    }
    try {
      const targetDeviceMode = resizeArgs.preset ? PRESET_TO_STORE_DEVICE_MODE[resizeArgs.preset] : void 0;
      if (targetDeviceMode) {
        const widthBeforeResize = window.innerWidth;
        const alreadyAtTargetWidth = targetDimensions !== null && Math.abs(widthBeforeResize - targetDimensions.width) <= ALREADY_AT_WIDTH_TOLERANCE_PX;
        if (!alreadyAtTargetWidth) {
          requestBuilderResizeIframeElement(targetDeviceMode, parentOrigin);
          const widthChanged = await waitForCondition(
            () => window.innerWidth !== widthBeforeResize,
            RESIZE_ACK_TIMEOUT_MS
          );
          if (!widthChanged && targetDeviceMode !== DEFAULT_DEVICE_MODE) {
            return {
              success: false,
              error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.BRIDGE_ERROR,
              data: {
                message: `resize to '${resizeArgs.preset}' was not applied \u2014 the iframe width did not change within ${RESIZE_ACK_TIMEOUT_MS}ms (the builder did not resize the preview). Captured at the current width; do not trust the requested viewport.`,
                applied_color_scheme: null
              }
            };
          }
        }
      }
      if (targetDimensions !== null) {
        applyViewportMetaForWidth(targetDimensions.width);
        dispatchViewportResizeEvents();
      }
      if (targetColorScheme) {
        applyColorSchemeAttribute(targetColorScheme);
      }
      return {
        success: true,
        data: {
          applied_dimensions: targetDimensions,
          applied_color_scheme: targetColorScheme ?? null,
          applied_device_mode: targetDeviceMode ?? null
        }
      };
    } catch (resizeError) {
      return {
        success: false,
        error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.BRIDGE_ERROR,
        data: { message: resizeError instanceof Error ? resizeError.message : String(resizeError) }
      };
    }
  }

  // ../../../node_modules/.pnpm/modern-screenshot@4.7.0/node_modules/modern-screenshot/dist/index.mjs
  var _P = "p".charCodeAt(0);
  var _H = "H".charCodeAt(0);
  var _Y = "Y".charCodeAt(0);
  var _S = "s".charCodeAt(0);
  var PREFIX = "[modern-screenshot]";
  var IN_BROWSER = typeof window !== "undefined";
  var SUPPORT_WEB_WORKER = IN_BROWSER && "Worker" in window;
  var SUPPORT_ATOB = IN_BROWSER && "atob" in window;
  var SUPPORT_BTOA = IN_BROWSER && "btoa" in window;
  var USER_AGENT = IN_BROWSER ? window.navigator?.userAgent : "";
  var IN_CHROME = USER_AGENT.includes("Chrome");
  var IN_SAFARI = USER_AGENT.includes("AppleWebKit") && !IN_CHROME;
  var IN_FIREFOX = USER_AGENT.includes("Firefox");
  var isContext = (value) => value && "__CONTEXT__" in value;
  var isCssFontFaceRule = (rule2) => rule2.constructor.name === "CSSFontFaceRule";
  var isCSSImportRule2 = (rule2) => rule2.constructor.name === "CSSImportRule";
  var isLayerBlockRule = (rule2) => rule2.constructor.name === "CSSLayerBlockRule";
  var isElementNode2 = (node2) => node2.nodeType === 1;
  var isSVGElementNode = (node2) => typeof node2.className === "object";
  var isSVGImageElementNode = (node2) => node2.tagName === "image";
  var isSVGUseElementNode = (node2) => node2.tagName === "use";
  var isHTMLElementNode = (node2) => isElementNode2(node2) && typeof node2.style !== "undefined" && !isSVGElementNode(node2);
  var isCommentNode = (node2) => node2.nodeType === 8;
  var isTextNode2 = (node2) => node2.nodeType === 3;
  var isImageElement = (node2) => node2.tagName === "IMG";
  var isVideoElement = (node2) => node2.tagName === "VIDEO";
  var isCanvasElement = (node2) => node2.tagName === "CANVAS";
  var isTextareaElement = (node2) => node2.tagName === "TEXTAREA";
  var isInputElement = (node2) => node2.tagName === "INPUT";
  var isStyleElement = (node2) => node2.tagName === "STYLE";
  var isScriptElement = (node2) => node2.tagName === "SCRIPT";
  var isSelectElement = (node2) => node2.tagName === "SELECT";
  var isSlotElement = (node2) => node2.tagName === "SLOT";
  var isIFrameElement = (node2) => node2.tagName === "IFRAME";
  var consoleWarn = (...args) => console.warn(PREFIX, ...args);
  function supportWebp(ownerDocument2) {
    const canvas = ownerDocument2?.createElement?.("canvas");
    if (canvas) {
      canvas.height = canvas.width = 1;
    }
    return Boolean(canvas) && "toDataURL" in canvas && Boolean(canvas.toDataURL("image/webp").includes("image/webp"));
  }
  var isDataUrl = (url) => url.startsWith("data:");
  function resolveUrl(url, baseUrl) {
    if (url.match(/^[a-z]+:\/\//i))
      return url;
    if (IN_BROWSER && url.match(/^\/\//))
      return window.location.protocol + url;
    if (url.match(/^[a-z]+:/i))
      return url;
    if (!IN_BROWSER)
      return url;
    const doc = getDocument().implementation.createHTMLDocument();
    const base = doc.createElement("base");
    const a = doc.createElement("a");
    doc.head.appendChild(base);
    doc.body.appendChild(a);
    if (baseUrl)
      base.href = baseUrl;
    a.href = url;
    return a.href;
  }
  function getDocument(target) {
    return (target && isElementNode2(target) ? target?.ownerDocument : target) ?? window.document;
  }
  var XMLNS = "http://www.w3.org/2000/svg";
  function createSvg(width, height, ownerDocument2) {
    const svg = getDocument(ownerDocument2).createElementNS(XMLNS, "svg");
    svg.setAttributeNS(null, "width", width.toString());
    svg.setAttributeNS(null, "height", height.toString());
    svg.setAttributeNS(null, "viewBox", `0 0 ${width} ${height}`);
    return svg;
  }
  function svgToDataUrl(svg, removeControlCharacter) {
    let xhtml = new XMLSerializer().serializeToString(svg);
    if (removeControlCharacter) {
      xhtml = xhtml.replace(/[\u0000-\u0008\v\f\u000E-\u001F\uD800-\uDFFF\uFFFE\uFFFF]/gu, "");
    }
    return `data:image/svg+xml;charset=utf-8,${encodeURIComponent(xhtml)}`;
  }
  function readBlob(blob2, type) {
    return new Promise((resolve2, reject) => {
      const reader = new FileReader();
      reader.onload = () => resolve2(reader.result);
      reader.onerror = () => reject(reader.error);
      reader.onabort = () => reject(new Error(`Failed read blob to ${type}`));
      if (type === "dataUrl") {
        reader.readAsDataURL(blob2);
      } else if (type === "arrayBuffer") {
        reader.readAsArrayBuffer(blob2);
      }
    });
  }
  var blobToDataUrl = (blob2) => readBlob(blob2, "dataUrl");
  function createImage(url, ownerDocument2) {
    const img = getDocument(ownerDocument2).createElement("img");
    img.decoding = "sync";
    img.loading = "eager";
    img.src = url;
    return img;
  }
  function loadMedia(media, options) {
    return new Promise((resolve2) => {
      const { timeout, ownerDocument: ownerDocument2, onError: userOnError, onWarn } = options ?? {};
      const node2 = typeof media === "string" ? createImage(media, getDocument(ownerDocument2)) : media;
      let timer = null;
      let removeEventListeners = null;
      function onResolve() {
        resolve2(node2);
        timer && clearTimeout(timer);
        removeEventListeners?.();
      }
      if (timeout) {
        timer = setTimeout(onResolve, timeout);
      }
      if (isVideoElement(node2)) {
        const currentSrc = node2.currentSrc || node2.src;
        if (!currentSrc) {
          if (node2.poster) {
            return loadMedia(node2.poster, options).then(resolve2);
          }
          return onResolve();
        }
        if (node2.readyState >= 2) {
          return onResolve();
        }
        const onLoadeddata = onResolve;
        const onError = (error) => {
          onWarn?.(
            "Failed video load",
            currentSrc,
            error
          );
          userOnError?.(error);
          onResolve();
        };
        removeEventListeners = () => {
          node2.removeEventListener("loadeddata", onLoadeddata);
          node2.removeEventListener("error", onError);
        };
        node2.addEventListener("loadeddata", onLoadeddata, { once: true });
        node2.addEventListener("error", onError, { once: true });
      } else {
        const currentSrc = isSVGImageElementNode(node2) ? node2.href.baseVal : node2.currentSrc || node2.src;
        if (!currentSrc) {
          return onResolve();
        }
        const onLoad = async () => {
          if (isImageElement(node2) && "decode" in node2) {
            try {
              await node2.decode();
            } catch (error) {
              onWarn?.(
                "Failed to decode image, trying to render anyway",
                node2.dataset.originalSrc || currentSrc,
                error
              );
            }
          }
          onResolve();
        };
        const onError = (error) => {
          onWarn?.(
            "Failed image load",
            node2.dataset.originalSrc || currentSrc,
            error
          );
          onResolve();
        };
        if (isImageElement(node2) && node2.complete) {
          return onLoad();
        }
        removeEventListeners = () => {
          node2.removeEventListener("load", onLoad);
          node2.removeEventListener("error", onError);
        };
        node2.addEventListener("load", onLoad, { once: true });
        node2.addEventListener("error", onError, { once: true });
      }
    });
  }
  async function waitUntilLoad(node2, options) {
    if (isHTMLElementNode(node2)) {
      if (isImageElement(node2) || isVideoElement(node2)) {
        await loadMedia(node2, options);
      } else {
        await Promise.all(
          ["img", "video"].flatMap((selectors) => {
            return Array.from(node2.querySelectorAll(selectors)).map((el) => loadMedia(el, options));
          })
        );
      }
    }
  }
  var uuid = /* @__PURE__ */ (function uuid2() {
    let counter = 0;
    const random = () => `0000${(Math.random() * 36 ** 4 << 0).toString(36)}`.slice(-4);
    return () => {
      counter += 1;
      return `u${random()}${counter}`;
    };
  })();
  function splitFontFamily(fontFamily) {
    return fontFamily?.split(",").map((val) => val.trim().replace(/"|'/g, "").toLowerCase()).filter(Boolean);
  }
  var uid = 0;
  function createLogger(debug) {
    const prefix = `${PREFIX}[#${uid}]`;
    uid++;
    return {
      // eslint-disable-next-line no-console
      time: (label) => debug && console.time(`${prefix} ${label}`),
      // eslint-disable-next-line no-console
      timeEnd: (label) => debug && console.timeEnd(`${prefix} ${label}`),
      warn: (...args) => debug && consoleWarn(...args)
    };
  }
  function getDefaultRequestInit(bypassingCache) {
    return {
      cache: bypassingCache ? "no-cache" : "force-cache"
    };
  }
  async function orCreateContext(node2, options) {
    return isContext(node2) ? node2 : createContext(node2, { ...options, autoDestruct: true });
  }
  async function createContext(node2, options) {
    const { scale = 1, workerUrl, workerNumber = 1 } = options || {};
    const debug = Boolean(options?.debug);
    const features = options?.features ?? true;
    const ownerDocument2 = node2.ownerDocument ?? (IN_BROWSER ? window.document : void 0);
    const ownerWindow = node2.ownerDocument?.defaultView ?? (IN_BROWSER ? window : void 0);
    const requests = /* @__PURE__ */ new Map();
    const context = {
      // Options
      width: 0,
      height: 0,
      quality: 1,
      type: "image/png",
      scale,
      backgroundColor: null,
      style: null,
      filter: null,
      maximumCanvasSize: 0,
      timeout: 3e4,
      progress: null,
      debug,
      fetch: {
        requestInit: getDefaultRequestInit(options?.fetch?.bypassingCache),
        placeholderImage: "data:image/png;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7",
        bypassingCache: false,
        ...options?.fetch
      },
      fetchFn: null,
      font: {},
      drawImageInterval: 100,
      workerUrl: null,
      workerNumber,
      onCloneEachNode: null,
      onCloneNode: null,
      onEmbedNode: null,
      onCreateForeignObjectSvg: null,
      includeStyleProperties: null,
      autoDestruct: false,
      ...options,
      // InternalContext
      __CONTEXT__: true,
      log: createLogger(debug),
      node: node2,
      ownerDocument: ownerDocument2,
      ownerWindow,
      dpi: scale === 1 ? null : 96 * scale,
      svgStyleElement: createStyleElement(ownerDocument2),
      svgDefsElement: ownerDocument2?.createElementNS(XMLNS, "defs"),
      svgStyles: /* @__PURE__ */ new Map(),
      defaultComputedStyles: /* @__PURE__ */ new Map(),
      workers: [
        ...Array.from({
          length: SUPPORT_WEB_WORKER && workerUrl && workerNumber ? workerNumber : 0
        })
      ].map(() => {
        try {
          const worker = new Worker(workerUrl);
          worker.onmessage = async (event) => {
            const { url, result: result2 } = event.data;
            if (result2) {
              requests.get(url)?.resolve?.(result2);
            } else {
              requests.get(url)?.reject?.(new Error(`Error receiving message from worker: ${url}`));
            }
          };
          worker.onmessageerror = (event) => {
            const { url } = event.data;
            requests.get(url)?.reject?.(new Error(`Error receiving message from worker: ${url}`));
          };
          return worker;
        } catch (error) {
          context.log.warn("Failed to new Worker", error);
          return null;
        }
      }).filter(Boolean),
      fontFamilies: /* @__PURE__ */ new Map(),
      fontCssTexts: /* @__PURE__ */ new Map(),
      acceptOfImage: `${[
        supportWebp(ownerDocument2) && "image/webp",
        "image/svg+xml",
        "image/*",
        "*/*"
      ].filter(Boolean).join(",")};q=0.8`,
      requests,
      drawImageCount: 0,
      tasks: [],
      features,
      isEnable: (key) => {
        if (key === "restoreScrollPosition") {
          return typeof features === "boolean" ? false : features[key] ?? false;
        }
        if (typeof features === "boolean") {
          return features;
        }
        return features[key] ?? true;
      },
      shadowRoots: []
    };
    context.log.time("wait until load");
    await waitUntilLoad(node2, { timeout: context.timeout, onWarn: context.log.warn });
    context.log.timeEnd("wait until load");
    const { width, height } = resolveBoundingBox(node2, context);
    context.width = width;
    context.height = height;
    return context;
  }
  function createStyleElement(ownerDocument2) {
    if (!ownerDocument2)
      return void 0;
    const style = ownerDocument2.createElement("style");
    const cssText = style.ownerDocument.createTextNode(`
.______background-clip--text {
  background-clip: text;
  -webkit-background-clip: text;
}
`);
    style.appendChild(cssText);
    return style;
  }
  function resolveBoundingBox(node2, context) {
    let { width, height } = context;
    if (isElementNode2(node2) && (!width || !height)) {
      const box = node2.getBoundingClientRect();
      width = width || box.width || Number(node2.getAttribute("width")) || 0;
      height = height || box.height || Number(node2.getAttribute("height")) || 0;
    }
    return { width, height };
  }
  async function imageToCanvas(image, context) {
    const {
      log,
      timeout,
      drawImageCount,
      drawImageInterval
    } = context;
    log.time("image to canvas");
    const loaded = await loadMedia(image, { timeout, onWarn: context.log.warn });
    const { canvas, context2d } = createCanvas(image.ownerDocument, context);
    const drawImage = () => {
      try {
        context2d?.drawImage(loaded, 0, 0, canvas.width, canvas.height);
      } catch (error) {
        context.log.warn("Failed to drawImage", error);
      }
    };
    drawImage();
    if (context.isEnable("fixSvgXmlDecode")) {
      for (let i = 0; i < drawImageCount; i++) {
        await new Promise((resolve2) => {
          setTimeout(() => {
            context2d?.clearRect(0, 0, canvas.width, canvas.height);
            drawImage();
            resolve2();
          }, i + drawImageInterval);
        });
      }
    }
    context.drawImageCount = 0;
    log.timeEnd("image to canvas");
    return canvas;
  }
  function createCanvas(ownerDocument2, context) {
    const { width, height, scale, backgroundColor, maximumCanvasSize: max } = context;
    const canvas = ownerDocument2.createElement("canvas");
    canvas.width = Math.floor(width * scale);
    canvas.height = Math.floor(height * scale);
    canvas.style.width = `${width}px`;
    canvas.style.height = `${height}px`;
    if (max) {
      if (canvas.width > max || canvas.height > max) {
        if (canvas.width > max && canvas.height > max) {
          if (canvas.width > canvas.height) {
            canvas.height *= max / canvas.width;
            canvas.width = max;
          } else {
            canvas.width *= max / canvas.height;
            canvas.height = max;
          }
        } else if (canvas.width > max) {
          canvas.height *= max / canvas.width;
          canvas.width = max;
        } else {
          canvas.width *= max / canvas.height;
          canvas.height = max;
        }
      }
    }
    const context2d = canvas.getContext("2d");
    if (context2d && backgroundColor) {
      context2d.fillStyle = backgroundColor;
      context2d.fillRect(0, 0, canvas.width, canvas.height);
    }
    return { canvas, context2d };
  }
  function cloneCanvas(canvas, context) {
    if (canvas.ownerDocument) {
      try {
        const dataURL = canvas.toDataURL();
        if (dataURL !== "data:,") {
          return createImage(dataURL, canvas.ownerDocument);
        }
      } catch (error) {
        context.log.warn("Failed to clone canvas", error);
      }
    }
    const cloned = canvas.cloneNode(false);
    const ctx = canvas.getContext("2d");
    const clonedCtx = cloned.getContext("2d");
    try {
      if (ctx && clonedCtx) {
        clonedCtx.putImageData(
          ctx.getImageData(0, 0, canvas.width, canvas.height),
          0,
          0
        );
      }
      return cloned;
    } catch (error) {
      context.log.warn("Failed to clone canvas", error);
    }
    return cloned;
  }
  function cloneIframe(iframe, context) {
    try {
      if (iframe?.contentDocument?.documentElement) {
        return cloneNode2(iframe.contentDocument.documentElement, context);
      }
    } catch (error) {
      context.log.warn("Failed to clone iframe", error);
    }
    return iframe.cloneNode(false);
  }
  function cloneImage(image) {
    const cloned = image.cloneNode(false);
    if (image.currentSrc && image.currentSrc !== image.src) {
      cloned.src = image.currentSrc;
      cloned.srcset = "";
    }
    if (cloned.loading === "lazy") {
      cloned.loading = "eager";
    }
    return cloned;
  }
  async function cloneVideo(video, context) {
    if (video.ownerDocument && !video.currentSrc && video.poster) {
      return createImage(video.poster, video.ownerDocument);
    }
    const cloned = video.cloneNode(false);
    cloned.crossOrigin = "anonymous";
    if (video.currentSrc && video.currentSrc !== video.src) {
      cloned.src = video.currentSrc;
    }
    const ownerDocument2 = cloned.ownerDocument;
    if (ownerDocument2) {
      let canPlay = true;
      await loadMedia(cloned, { onError: () => canPlay = false, onWarn: context.log.warn });
      if (!canPlay) {
        if (video.poster) {
          return createImage(video.poster, video.ownerDocument);
        }
        return cloned;
      }
      cloned.currentTime = video.currentTime;
      await new Promise((resolve2) => {
        cloned.addEventListener("seeked", resolve2, { once: true });
      });
      const canvas = ownerDocument2.createElement("canvas");
      canvas.width = video.offsetWidth;
      canvas.height = video.offsetHeight;
      try {
        const ctx = canvas.getContext("2d");
        if (ctx)
          ctx.drawImage(cloned, 0, 0, canvas.width, canvas.height);
      } catch (error) {
        context.log.warn("Failed to clone video", error);
        if (video.poster) {
          return createImage(video.poster, video.ownerDocument);
        }
        return cloned;
      }
      return cloneCanvas(canvas, context);
    }
    return cloned;
  }
  function cloneElement(node2, context) {
    if (isCanvasElement(node2)) {
      return cloneCanvas(node2, context);
    }
    if (isIFrameElement(node2)) {
      return cloneIframe(node2, context);
    }
    if (isImageElement(node2)) {
      return cloneImage(node2);
    }
    if (isVideoElement(node2)) {
      return cloneVideo(node2, context);
    }
    return node2.cloneNode(false);
  }
  function getSandBox(context) {
    let sandbox = context.sandbox;
    if (!sandbox) {
      const { ownerDocument: ownerDocument2 } = context;
      try {
        if (ownerDocument2) {
          sandbox = ownerDocument2.createElement("iframe");
          sandbox.id = `__SANDBOX__${uuid()}`;
          sandbox.width = "0";
          sandbox.height = "0";
          sandbox.style.visibility = "hidden";
          sandbox.style.position = "fixed";
          ownerDocument2.body.appendChild(sandbox);
          sandbox.srcdoc = '<!DOCTYPE html><meta charset="UTF-8"><title></title><body>';
          context.sandbox = sandbox;
        }
      } catch (error) {
        context.log.warn("Failed to getSandBox", error);
      }
    }
    return sandbox;
  }
  var ignoredStyles = [
    "width",
    "height",
    "-webkit-text-fill-color"
  ];
  var includedAttributes = [
    "stroke",
    "fill"
  ];
  function getDefaultStyle(node2, pseudoElement, context) {
    const { defaultComputedStyles } = context;
    const nodeName = node2.nodeName.toLowerCase();
    const isSvgNode = isSVGElementNode(node2) && nodeName !== "svg";
    const attributes = isSvgNode ? includedAttributes.map((name) => [name, node2.getAttribute(name)]).filter(([, value]) => value !== null) : [];
    const key = [
      isSvgNode && "svg",
      nodeName,
      attributes.map((name, value) => `${name}=${value}`).join(","),
      pseudoElement
    ].filter(Boolean).join(":");
    if (defaultComputedStyles.has(key))
      return defaultComputedStyles.get(key);
    const sandbox = getSandBox(context);
    const sandboxWindow = sandbox?.contentWindow;
    if (!sandboxWindow)
      return /* @__PURE__ */ new Map();
    const sandboxDocument = sandboxWindow?.document;
    let root2;
    let el;
    if (isSvgNode) {
      root2 = sandboxDocument.createElementNS(XMLNS, "svg");
      el = root2.ownerDocument.createElementNS(root2.namespaceURI, nodeName);
      attributes.forEach(([name, value]) => {
        el.setAttributeNS(null, name, value);
      });
      root2.appendChild(el);
    } else {
      root2 = el = sandboxDocument.createElement(nodeName);
    }
    el.textContent = " ";
    sandboxDocument.body.appendChild(root2);
    const computedStyle = sandboxWindow.getComputedStyle(el, pseudoElement);
    const styles = /* @__PURE__ */ new Map();
    for (let len = computedStyle.length, i = 0; i < len; i++) {
      const name = computedStyle.item(i);
      if (ignoredStyles.includes(name))
        continue;
      styles.set(name, computedStyle.getPropertyValue(name));
    }
    sandboxDocument.body.removeChild(root2);
    defaultComputedStyles.set(key, styles);
    return styles;
  }
  function getDiffStyle(style, defaultStyle, includeStyleProperties) {
    const diffStyle = /* @__PURE__ */ new Map();
    const prefixs = [];
    const prefixTree = /* @__PURE__ */ new Map();
    if (includeStyleProperties) {
      for (const name of includeStyleProperties) {
        applyTo(name);
      }
    } else {
      for (let len = style.length, i = 0; i < len; i++) {
        const name = style.item(i);
        applyTo(name);
      }
    }
    for (let len = prefixs.length, i = 0; i < len; i++) {
      prefixTree.get(prefixs[i])?.forEach((value, name) => diffStyle.set(name, value));
    }
    function applyTo(name) {
      const value = style.getPropertyValue(name);
      const priority = style.getPropertyPriority(name);
      const subIndex = name.lastIndexOf("-");
      const prefix = subIndex > -1 ? name.substring(0, subIndex) : void 0;
      if (prefix) {
        let map = prefixTree.get(prefix);
        if (!map) {
          map = /* @__PURE__ */ new Map();
          prefixTree.set(prefix, map);
        }
        map.set(name, [value, priority]);
      }
      if (defaultStyle.get(name) === value && !priority)
        return;
      if (prefix) {
        prefixs.push(prefix);
      } else {
        diffStyle.set(name, [value, priority]);
      }
    }
    return diffStyle;
  }
  function copyCssStyles(node2, cloned, isRoot, context) {
    const { ownerWindow, includeStyleProperties, currentParentNodeStyle } = context;
    const clonedStyle = cloned.style;
    const computedStyle = ownerWindow.getComputedStyle(node2);
    const defaultStyle = getDefaultStyle(node2, null, context);
    currentParentNodeStyle?.forEach((_, key) => {
      defaultStyle.delete(key);
    });
    const style = getDiffStyle(computedStyle, defaultStyle, includeStyleProperties);
    style.delete("transition-property");
    style.delete("all");
    style.delete("d");
    style.delete("content");
    if (isRoot) {
      style.delete("position");
      style.delete("margin-top");
      style.delete("margin-right");
      style.delete("margin-bottom");
      style.delete("margin-left");
      style.delete("margin-block-start");
      style.delete("margin-block-end");
      style.delete("margin-inline-start");
      style.delete("margin-inline-end");
      style.set("box-sizing", ["border-box", ""]);
    }
    if (style.get("background-clip")?.[0] === "text") {
      cloned.classList.add("______background-clip--text");
    }
    if (IN_CHROME) {
      if (!style.has("font-kerning"))
        style.set("font-kerning", ["normal", ""]);
      if ((style.get("overflow-x")?.[0] === "hidden" || style.get("overflow-y")?.[0] === "hidden") && style.get("text-overflow")?.[0] === "ellipsis" && node2.scrollWidth === node2.clientWidth) {
        style.set("text-overflow", ["clip", ""]);
      }
    }
    for (let len = clonedStyle.length, i = 0; i < len; i++) {
      clonedStyle.removeProperty(clonedStyle.item(i));
    }
    style.forEach(([value, priority], name) => {
      clonedStyle.setProperty(name, value, priority);
    });
    return style;
  }
  function copyInputValue(node2, cloned) {
    if (isTextareaElement(node2) || isInputElement(node2) || isSelectElement(node2)) {
      cloned.setAttribute("value", node2.value);
    }
  }
  var pseudoClasses = [
    "::before",
    "::after"
    // '::placeholder', TODO
  ];
  var scrollbarPseudoClasses = [
    "::-webkit-scrollbar",
    "::-webkit-scrollbar-button",
    // '::-webkit-scrollbar:horizontal', TODO
    "::-webkit-scrollbar-thumb",
    "::-webkit-scrollbar-track",
    "::-webkit-scrollbar-track-piece",
    // '::-webkit-scrollbar:vertical', TODO
    "::-webkit-scrollbar-corner",
    "::-webkit-resizer"
  ];
  function copyPseudoClass(node2, cloned, copyScrollbar, context, addWordToFontFamilies) {
    const { ownerWindow, svgStyleElement, svgStyles, currentNodeStyle } = context;
    if (!svgStyleElement || !ownerWindow)
      return;
    function copyBy(pseudoClass) {
      const computedStyle = ownerWindow.getComputedStyle(node2, pseudoClass);
      let content = computedStyle.getPropertyValue("content");
      if (!content || content === "none")
        return;
      addWordToFontFamilies?.(content);
      content = content.replace(/(')|(")|(counter\(.+\))/g, "");
      const klasses = [uuid()];
      const defaultStyle = getDefaultStyle(node2, pseudoClass, context);
      currentNodeStyle?.forEach((_, key) => {
        defaultStyle.delete(key);
      });
      const style = getDiffStyle(computedStyle, defaultStyle, context.includeStyleProperties);
      style.delete("content");
      style.delete("-webkit-locale");
      if (style.get("background-clip")?.[0] === "text") {
        cloned.classList.add("______background-clip--text");
      }
      const cloneStyle = [
        `content: '${content}';`
      ];
      style.forEach(([value, priority], name) => {
        cloneStyle.push(`${name}: ${value}${priority ? " !important" : ""};`);
      });
      if (cloneStyle.length === 1)
        return;
      try {
        cloned.className = [cloned.className, ...klasses].join(" ");
      } catch (err) {
        context.log.warn("Failed to copyPseudoClass", err);
        return;
      }
      const cssText = cloneStyle.join("\n  ");
      let allClasses = svgStyles.get(cssText);
      if (!allClasses) {
        allClasses = [];
        svgStyles.set(cssText, allClasses);
      }
      allClasses.push(`.${klasses[0]}${pseudoClass}`);
    }
    pseudoClasses.forEach(copyBy);
    if (copyScrollbar)
      scrollbarPseudoClasses.forEach(copyBy);
  }
  var excludeParentNodes = /* @__PURE__ */ new Set([
    "symbol"
    // test/fixtures/svg.symbol.html
  ]);
  async function appendChildNode(node2, cloned, child, context, addWordToFontFamilies) {
    if (isElementNode2(child) && (isStyleElement(child) || isScriptElement(child)))
      return;
    if (context.filter && !context.filter(child))
      return;
    if (excludeParentNodes.has(cloned.nodeName) || excludeParentNodes.has(child.nodeName)) {
      context.currentParentNodeStyle = void 0;
    } else {
      context.currentParentNodeStyle = context.currentNodeStyle;
    }
    const childCloned = await cloneNode2(child, context, false, addWordToFontFamilies);
    if (context.isEnable("restoreScrollPosition")) {
      restoreScrollPosition(node2, childCloned);
    }
    cloned.appendChild(childCloned);
  }
  async function cloneChildNodes(node2, cloned, context, addWordToFontFamilies) {
    let firstChild = node2.firstChild;
    if (isElementNode2(node2)) {
      if (node2.shadowRoot) {
        firstChild = node2.shadowRoot?.firstChild;
        context.shadowRoots.push(node2.shadowRoot);
      }
    }
    for (let child = firstChild; child; child = child.nextSibling) {
      if (isCommentNode(child))
        continue;
      if (isElementNode2(child) && isSlotElement(child) && typeof child.assignedNodes === "function") {
        const nodes = child.assignedNodes();
        for (let i = 0; i < nodes.length; i++) {
          await appendChildNode(node2, cloned, nodes[i], context, addWordToFontFamilies);
        }
      } else {
        await appendChildNode(node2, cloned, child, context, addWordToFontFamilies);
      }
    }
  }
  function restoreScrollPosition(node2, chlidCloned) {
    if (!isHTMLElementNode(node2) || !isHTMLElementNode(chlidCloned))
      return;
    const { scrollTop, scrollLeft } = node2;
    if (!scrollTop && !scrollLeft) {
      return;
    }
    const { transform } = chlidCloned.style;
    const matrix = new DOMMatrix(transform);
    const { a, b, c, d } = matrix;
    matrix.a = 1;
    matrix.b = 0;
    matrix.c = 0;
    matrix.d = 1;
    matrix.translateSelf(-scrollLeft, -scrollTop);
    matrix.a = a;
    matrix.b = b;
    matrix.c = c;
    matrix.d = d;
    chlidCloned.style.transform = matrix.toString();
  }
  function applyCssStyleWithOptions(cloned, context) {
    const { backgroundColor, width, height, style: styles } = context;
    const clonedStyle = cloned.style;
    if (backgroundColor)
      clonedStyle.setProperty("background-color", backgroundColor, "important");
    if (width)
      clonedStyle.setProperty("width", `${width}px`, "important");
    if (height)
      clonedStyle.setProperty("height", `${height}px`, "important");
    if (styles) {
      for (const name in styles) clonedStyle[name] = styles[name];
    }
  }
  var NORMAL_ATTRIBUTE_RE = /^[\w-:]+$/;
  async function cloneNode2(node2, context, isRoot = false, addWordToFontFamilies) {
    const { ownerDocument: ownerDocument2, ownerWindow, fontFamilies, onCloneEachNode } = context;
    if (ownerDocument2 && isTextNode2(node2)) {
      if (addWordToFontFamilies && /\S/.test(node2.data)) {
        addWordToFontFamilies(node2.data);
      }
      return ownerDocument2.createTextNode(node2.data);
    }
    if (ownerDocument2 && ownerWindow && isElementNode2(node2) && (isHTMLElementNode(node2) || isSVGElementNode(node2))) {
      const cloned2 = await cloneElement(node2, context);
      if (context.isEnable("removeAbnormalAttributes")) {
        const names = cloned2.getAttributeNames();
        for (let len = names.length, i = 0; i < len; i++) {
          const name = names[i];
          if (!NORMAL_ATTRIBUTE_RE.test(name)) {
            cloned2.removeAttribute(name);
          }
        }
      }
      const style = context.currentNodeStyle = copyCssStyles(node2, cloned2, isRoot, context);
      if (isRoot)
        applyCssStyleWithOptions(cloned2, context);
      let copyScrollbar = false;
      if (context.isEnable("copyScrollbar")) {
        const overflow = [
          style.get("overflow-x")?.[0],
          style.get("overflow-y")?.[0]
        ];
        copyScrollbar = overflow.includes("scroll") || (overflow.includes("auto") || overflow.includes("overlay")) && (node2.scrollHeight > node2.clientHeight || node2.scrollWidth > node2.clientWidth);
      }
      const textTransform = style.get("text-transform")?.[0];
      const families = splitFontFamily(style.get("font-family")?.[0]);
      const addWordToFontFamilies2 = families ? (word) => {
        if (textTransform === "uppercase") {
          word = word.toUpperCase();
        } else if (textTransform === "lowercase") {
          word = word.toLowerCase();
        } else if (textTransform === "capitalize") {
          word = word[0].toUpperCase() + word.substring(1);
        }
        families.forEach((family) => {
          let fontFamily = fontFamilies.get(family);
          if (!fontFamily) {
            fontFamilies.set(family, fontFamily = /* @__PURE__ */ new Set());
          }
          word.split("").forEach((text) => fontFamily.add(text));
        });
      } : void 0;
      copyPseudoClass(
        node2,
        cloned2,
        copyScrollbar,
        context,
        addWordToFontFamilies2
      );
      copyInputValue(node2, cloned2);
      if (!isVideoElement(node2)) {
        await cloneChildNodes(
          node2,
          cloned2,
          context,
          addWordToFontFamilies2
        );
      }
      await onCloneEachNode?.(cloned2);
      return cloned2;
    }
    const cloned = node2.cloneNode(false);
    await cloneChildNodes(node2, cloned, context);
    await onCloneEachNode?.(cloned);
    return cloned;
  }
  function destroyContext(context) {
    context.ownerDocument = void 0;
    context.ownerWindow = void 0;
    context.svgStyleElement = void 0;
    context.svgDefsElement = void 0;
    context.svgStyles.clear();
    context.defaultComputedStyles.clear();
    if (context.sandbox) {
      try {
        context.sandbox.remove();
      } catch (err) {
        context.log.warn("Failed to destroyContext", err);
      }
      context.sandbox = void 0;
    }
    context.workers = [];
    context.fontFamilies.clear();
    context.fontCssTexts.clear();
    context.requests.clear();
    context.tasks = [];
    context.shadowRoots = [];
  }
  function baseFetch(options) {
    const { url, timeout, responseType, ...requestInit } = options;
    const controller = new AbortController();
    const timer = timeout ? setTimeout(() => controller.abort(), timeout) : void 0;
    return fetch(url, { signal: controller.signal, ...requestInit }).then((response) => {
      if (!response.ok) {
        throw new Error("Failed fetch, not 2xx response", { cause: response });
      }
      switch (responseType) {
        case "arrayBuffer":
          return response.arrayBuffer();
        case "dataUrl":
          return response.blob().then(blobToDataUrl);
        case "text":
        default:
          return response.text();
      }
    }).finally(() => clearTimeout(timer));
  }
  function contextFetch(context, options) {
    const { url: rawUrl, requestType = "text", responseType = "text", imageDom } = options;
    let url = rawUrl;
    const {
      timeout,
      acceptOfImage,
      requests,
      fetchFn,
      fetch: {
        requestInit,
        bypassingCache,
        placeholderImage
      },
      font,
      workers,
      fontFamilies
    } = context;
    if (requestType === "image" && (IN_SAFARI || IN_FIREFOX)) {
      context.drawImageCount++;
    }
    let request = requests.get(rawUrl);
    if (!request) {
      if (bypassingCache) {
        if (bypassingCache instanceof RegExp && bypassingCache.test(url)) {
          url += (/\?/.test(url) ? "&" : "?") + (/* @__PURE__ */ new Date()).getTime();
        }
      }
      const canFontMinify = requestType.startsWith("font") && font && font.minify;
      const fontTexts = /* @__PURE__ */ new Set();
      if (canFontMinify) {
        const families = requestType.split(";")[1].split(",");
        families.forEach((family) => {
          if (!fontFamilies.has(family))
            return;
          fontFamilies.get(family).forEach((text) => fontTexts.add(text));
        });
      }
      const needFontMinify = canFontMinify && fontTexts.size;
      const baseFetchOptions = {
        url,
        timeout,
        responseType: needFontMinify ? "arrayBuffer" : responseType,
        headers: requestType === "image" ? { accept: acceptOfImage } : void 0,
        ...requestInit
      };
      request = {
        type: requestType,
        resolve: void 0,
        reject: void 0,
        response: null
      };
      request.response = (async () => {
        if (fetchFn && requestType === "image") {
          const result2 = await fetchFn(rawUrl);
          if (result2)
            return result2;
        }
        if (!IN_SAFARI && rawUrl.startsWith("http") && workers.length) {
          return new Promise((resolve2, reject) => {
            const worker = workers[requests.size & workers.length - 1];
            worker.postMessage({ rawUrl, ...baseFetchOptions });
            request.resolve = resolve2;
            request.reject = reject;
          });
        }
        return baseFetch(baseFetchOptions);
      })().catch((error) => {
        requests.delete(rawUrl);
        if (requestType === "image" && placeholderImage) {
          context.log.warn("Failed to fetch image base64, trying to use placeholder image", url);
          return typeof placeholderImage === "string" ? placeholderImage : placeholderImage(imageDom);
        }
        throw error;
      });
      requests.set(rawUrl, request);
    }
    return request.response;
  }
  async function replaceCssUrlToDataUrl(cssText, baseUrl, context, isImage) {
    if (!hasCssUrl(cssText))
      return cssText;
    for (const [rawUrl, url] of parseCssUrls(cssText, baseUrl)) {
      try {
        const dataUrl = await contextFetch(
          context,
          {
            url,
            requestType: isImage ? "image" : "text",
            responseType: "dataUrl"
          }
        );
        cssText = cssText.replace(toRE(rawUrl), `$1${dataUrl}$3`);
      } catch (error) {
        context.log.warn("Failed to fetch css data url", rawUrl, error);
      }
    }
    return cssText;
  }
  function hasCssUrl(cssText) {
    return /url\((['"]?)([^'"]+?)\1\)/.test(cssText);
  }
  var URL_RE = /url\((['"]?)([^'"]+?)\1\)/g;
  function parseCssUrls(cssText, baseUrl) {
    const result2 = [];
    cssText.replace(URL_RE, (raw, quotation, url) => {
      result2.push([url, resolveUrl(url, baseUrl)]);
      return raw;
    });
    return result2.filter(([url]) => !isDataUrl(url));
  }
  function toRE(url) {
    const escaped = url.replace(/([.*+?^${}()|\[\]\/\\])/g, "\\$1");
    return new RegExp(`(url\\(['"]?)(${escaped})(['"]?\\))`, "g");
  }
  var properties = [
    "background-image",
    "border-image-source",
    "-webkit-border-image",
    "-webkit-mask-image",
    "list-style-image"
  ];
  function embedCssStyleImage(style, context) {
    return properties.map((property) => {
      const value = style.getPropertyValue(property);
      if (!value || value === "none") {
        return null;
      }
      if (IN_SAFARI || IN_FIREFOX) {
        context.drawImageCount++;
      }
      return replaceCssUrlToDataUrl(value, null, context, true).then((newValue) => {
        if (!newValue || value === newValue)
          return;
        style.setProperty(
          property,
          newValue,
          style.getPropertyPriority(property)
        );
      });
    }).filter(Boolean);
  }
  function embedImageElement(cloned, context) {
    if (isImageElement(cloned)) {
      const originalSrc = cloned.currentSrc || cloned.src;
      if (!isDataUrl(originalSrc)) {
        return [
          contextFetch(context, {
            url: originalSrc,
            imageDom: cloned,
            requestType: "image",
            responseType: "dataUrl"
          }).then((url) => {
            if (!url)
              return;
            cloned.srcset = "";
            cloned.dataset.originalSrc = originalSrc;
            cloned.src = url || "";
          })
        ];
      }
      if (IN_SAFARI || IN_FIREFOX) {
        context.drawImageCount++;
      }
    } else if (isSVGElementNode(cloned) && !isDataUrl(cloned.href.baseVal)) {
      const originalSrc = cloned.href.baseVal;
      return [
        contextFetch(context, {
          url: originalSrc,
          imageDom: cloned,
          requestType: "image",
          responseType: "dataUrl"
        }).then((url) => {
          if (!url)
            return;
          cloned.dataset.originalSrc = originalSrc;
          cloned.href.baseVal = url || "";
        })
      ];
    }
    return [];
  }
  function embedSvgUse(cloned, context) {
    const { ownerDocument: ownerDocument2, svgDefsElement } = context;
    const href = cloned.getAttribute("href") ?? cloned.getAttribute("xlink:href");
    if (!href)
      return [];
    const [svgUrl, id] = href.split("#");
    if (id) {
      const query = `#${id}`;
      const definition = context.shadowRoots.reduce(
        (res, root2) => {
          return res ?? root2.querySelector(`svg ${query}`);
        },
        ownerDocument2?.querySelector(`svg ${query}`)
      );
      if (svgUrl) {
        cloned.setAttribute("href", query);
      }
      if (svgDefsElement?.querySelector(query))
        return [];
      if (definition) {
        svgDefsElement?.appendChild(definition.cloneNode(true));
        return [];
      } else if (svgUrl) {
        return [
          contextFetch(context, {
            url: svgUrl,
            responseType: "text"
          }).then((svgData) => {
            svgDefsElement?.insertAdjacentHTML("beforeend", svgData);
          })
        ];
      }
    }
    return [];
  }
  function embedNode(cloned, context) {
    const { tasks } = context;
    if (isElementNode2(cloned)) {
      if (isImageElement(cloned) || isSVGImageElementNode(cloned)) {
        tasks.push(...embedImageElement(cloned, context));
      }
      if (isSVGUseElementNode(cloned)) {
        tasks.push(...embedSvgUse(cloned, context));
      }
    }
    if (isHTMLElementNode(cloned)) {
      tasks.push(...embedCssStyleImage(cloned.style, context));
    }
    cloned.childNodes.forEach((child) => {
      embedNode(child, context);
    });
  }
  async function embedWebFont(clone, context) {
    const {
      ownerDocument: ownerDocument2,
      svgStyleElement,
      fontFamilies,
      fontCssTexts,
      tasks,
      font
    } = context;
    if (!ownerDocument2 || !svgStyleElement || !fontFamilies.size) {
      return;
    }
    if (font && font.cssText) {
      const cssText = filterPreferredFormat(font.cssText, context);
      svgStyleElement.appendChild(ownerDocument2.createTextNode(`${cssText}
`));
    } else {
      const styleSheets2 = Array.from(ownerDocument2.styleSheets).filter((styleSheet) => {
        try {
          return "cssRules" in styleSheet && Boolean(styleSheet.cssRules.length);
        } catch (error) {
          context.log.warn(`Error while reading CSS rules from ${styleSheet.href}`, error);
          return false;
        }
      });
      const tempDoc = ownerDocument2.implementation.createHTMLDocument("");
      const tempStyleEl = tempDoc.createElement("style");
      tempDoc.head.appendChild(tempStyleEl);
      const tempStyleSheet = tempStyleEl.sheet;
      await Promise.all(
        styleSheets2.flatMap((styleSheet) => {
          return Array.from(styleSheet.cssRules).map(async (cssRule) => {
            if (isCSSImportRule2(cssRule)) {
              const baseUrl = cssRule.href;
              let cssText = "";
              try {
                cssText = await contextFetch(context, {
                  url: baseUrl,
                  requestType: "text",
                  responseType: "text"
                });
              } catch (error) {
                context.log.warn(`Error fetch remote css import from ${baseUrl}`, error);
              }
              const replacedCssText = cssText.replace(
                URL_RE,
                (raw, quotation, url) => raw.replace(url, resolveUrl(url, baseUrl))
              );
              for (const rule2 of parseCss(replacedCssText)) {
                try {
                  tempStyleSheet.insertRule(rule2, tempStyleSheet.cssRules.length);
                } catch (error) {
                  context.log.warn("Error inserting rule from remote css import", { rule: rule2, error });
                }
              }
            }
          });
        })
      );
      if (tempStyleSheet.cssRules.length)
        styleSheets2.push(tempStyleSheet);
      const cssRules = [];
      styleSheets2.forEach((sheet) => {
        unwrapCssLayers(sheet.cssRules, cssRules);
      });
      cssRules.filter((cssRule) => isCssFontFaceRule(cssRule) && hasCssUrl(cssRule.style.getPropertyValue("src")) && splitFontFamily(cssRule.style.getPropertyValue("font-family"))?.some((val) => fontFamilies.has(val))).forEach((value) => {
        const rule2 = value;
        const cssText = fontCssTexts.get(rule2.cssText);
        if (cssText) {
          svgStyleElement.appendChild(ownerDocument2.createTextNode(`${cssText}
`));
        } else {
          tasks.push(
            replaceCssUrlToDataUrl(
              rule2.cssText,
              rule2.parentStyleSheet ? rule2.parentStyleSheet.href : null,
              context
            ).then((cssText2) => {
              cssText2 = filterPreferredFormat(cssText2, context);
              fontCssTexts.set(rule2.cssText, cssText2);
              svgStyleElement.appendChild(ownerDocument2.createTextNode(`${cssText2}
`));
            })
          );
        }
      });
    }
  }
  var COMMENTS_RE = /(\/\*[\s\S]*?\*\/)/g;
  var KEYFRAMES_RE = /((@.*?keyframes [\s\S]*?){([\s\S]*?}\s*?)})/gi;
  function parseCss(source) {
    if (source == null)
      return [];
    const result2 = [];
    let cssText = source.replace(COMMENTS_RE, "");
    while (true) {
      const matches = KEYFRAMES_RE.exec(cssText);
      if (!matches)
        break;
      result2.push(matches[0]);
    }
    cssText = cssText.replace(KEYFRAMES_RE, "");
    const IMPORT_RE = /@import[\s\S]*?url\([^)]*\)[\s\S]*?;/gi;
    const UNIFIED_RE = new RegExp(
      // eslint-disable-next-line
      "((\\s*?(?:\\/\\*[\\s\\S]*?\\*\\/)?\\s*?@media[\\s\\S]*?){([\\s\\S]*?)}\\s*?})|(([\\s\\S]*?){([\\s\\S]*?)})",
      "gi"
    );
    while (true) {
      let matches = IMPORT_RE.exec(cssText);
      if (!matches) {
        matches = UNIFIED_RE.exec(cssText);
        if (!matches) {
          break;
        } else {
          IMPORT_RE.lastIndex = UNIFIED_RE.lastIndex;
        }
      } else {
        UNIFIED_RE.lastIndex = IMPORT_RE.lastIndex;
      }
      result2.push(matches[0]);
    }
    return result2;
  }
  var URL_WITH_FORMAT_RE = /url\([^)]+\)\s*format\((["']?)([^"']+)\1\)/g;
  var FONT_SRC_RE = /src:\s*(?:url\([^)]+\)\s*format\([^)]+\)[,;]\s*)+/g;
  function filterPreferredFormat(str, context) {
    const { font } = context;
    const preferredFormat = font ? font?.preferredFormat : void 0;
    return preferredFormat ? str.replace(FONT_SRC_RE, (match) => {
      while (true) {
        const [src, , format] = URL_WITH_FORMAT_RE.exec(match) || [];
        if (!format)
          return "";
        if (format === preferredFormat)
          return `src: ${src};`;
      }
    }) : str;
  }
  function unwrapCssLayers(rules, out = []) {
    for (const rule2 of Array.from(rules)) {
      if (isLayerBlockRule(rule2)) {
        out.push(...unwrapCssLayers(rule2.cssRules));
      } else if ("cssRules" in rule2) {
        unwrapCssLayers(rule2.cssRules, out);
      } else {
        out.push(rule2);
      }
    }
    return out;
  }
  var SVG_EXTERNAL_RESOURCE_REGEX = /\bx?link:?href\s*=\s*["'](?!data:)[^"']+["']/i;
  function svgHasExternalResources(svg) {
    return SVG_EXTERNAL_RESOURCE_REGEX.test(svg.innerHTML);
  }
  async function domToForeignObjectSvg(node2, options) {
    const context = await orCreateContext(node2, options);
    if (isElementNode2(context.node) && isSVGElementNode(context.node) && !svgHasExternalResources(context.node))
      return context.node;
    const {
      ownerDocument: ownerDocument2,
      log,
      tasks,
      svgStyleElement,
      svgDefsElement,
      svgStyles,
      font,
      progress,
      autoDestruct,
      onCloneNode,
      onEmbedNode,
      onCreateForeignObjectSvg
    } = context;
    log.time("clone node");
    const clone = await cloneNode2(context.node, context, true);
    if (svgStyleElement && ownerDocument2) {
      let allCssText = "";
      svgStyles.forEach((klasses, cssText) => {
        allCssText += `${klasses.join(",\n")} {
  ${cssText}
}
`;
      });
      svgStyleElement.appendChild(ownerDocument2.createTextNode(allCssText));
    }
    log.timeEnd("clone node");
    await onCloneNode?.(clone);
    if (font !== false && isElementNode2(clone)) {
      log.time("embed web font");
      await embedWebFont(clone, context);
      log.timeEnd("embed web font");
    }
    log.time("embed node");
    embedNode(clone, context);
    const count = tasks.length;
    let current = 0;
    const runTask = async () => {
      while (true) {
        const task = tasks.pop();
        if (!task)
          break;
        try {
          await task;
        } catch (error) {
          context.log.warn("Failed to run task", error);
        }
        progress?.(++current, count);
      }
    };
    progress?.(current, count);
    await Promise.all([...Array.from({ length: 4 })].map(runTask));
    log.timeEnd("embed node");
    await onEmbedNode?.(clone);
    const svg = createForeignObjectSvg(clone, context);
    svgDefsElement && svg.insertBefore(svgDefsElement, svg.children[0]);
    svgStyleElement && svg.insertBefore(svgStyleElement, svg.children[0]);
    autoDestruct && destroyContext(context);
    await onCreateForeignObjectSvg?.(svg);
    return svg;
  }
  function createForeignObjectSvg(clone, context) {
    const { width, height } = context;
    const svg = createSvg(width, height, clone.ownerDocument);
    const foreignObject = svg.ownerDocument.createElementNS(svg.namespaceURI, "foreignObject");
    foreignObject.setAttributeNS(null, "x", "0%");
    foreignObject.setAttributeNS(null, "y", "0%");
    foreignObject.setAttributeNS(null, "width", "100%");
    foreignObject.setAttributeNS(null, "height", "100%");
    foreignObject.append(clone);
    svg.appendChild(foreignObject);
    return svg;
  }
  async function domToCanvas(node2, options) {
    const context = await orCreateContext(node2, options);
    const svg = await domToForeignObjectSvg(context);
    const dataUrl = svgToDataUrl(svg, context.isEnable("removeControlCharacter"));
    if (!context.autoDestruct) {
      context.svgStyleElement = createStyleElement(context.ownerDocument);
      context.svgDefsElement = context.ownerDocument?.createElementNS(XMLNS, "defs");
      context.svgStyles.clear();
    }
    const image = createImage(dataUrl, svg.ownerDocument);
    return await imageToCanvas(image, context);
  }

  // src/builder-bridge/preview-lens/screenshot.ts
  var DOM_TO_CANVAS_TOTAL_TIMEOUT_MS = 15e3;
  var RENDER_ASSET_FETCH_TIMEOUT_MS = 3e3;
  var BLANK_DETECTION_SAMPLE_SIZE = 50;
  var BLANK_PIXEL_RATIO_THRESHOLD = 0.999;
  var DOM_CONTENT_MIN_CHARS = 30;
  var MIN_VISIBLE_LAYOUT_ELEMENTS = 2;
  var CAPTURE_TARGET_LAYOUT_READY_TIMEOUT_MS = 1e3;
  var CAPTURE_TARGET_LAYOUT_READY_POLL_INTERVAL_MS = 50;
  var ZERO_SIZE_RENDER_RETRY_TIMEOUT_MS = 5e3;
  var ZERO_SIZE_RENDER_RETRY_INTERVAL_MS = 250;
  var MAX_CANVAS_EDGE_PX = 2048;
  var MAX_ENCODED_IMAGE_BASE64_BYTES = 8e5;
  var MIN_ENCODED_IMAGE_EDGE_PX = 320;
  var MAX_BYTE_CAP_RE_ENCODE_ATTEMPTS = 5;
  var FONTS_READY_TIMEOUT_MS = 2e3;
  var ANIMATION_SETTLE_TIMEOUT_MS = 600;
  function extractBase64FromDataUrl(dataUrl) {
    const commaIndex = dataUrl.indexOf(",");
    if (commaIndex === -1) return dataUrl;
    return dataUrl.slice(commaIndex + 1);
  }
  function finiteDimension(value) {
    return Number.isFinite(value) ? value : 0;
  }
  function cropCanvasToViewport(sourceCanvas, sourceTarget) {
    const viewportWidthCss = window.innerWidth;
    const viewportHeightCss = window.innerHeight;
    if (viewportWidthCss <= 0 || viewportHeightCss <= 0) return sourceCanvas;
    if (sourceTarget.width <= 0 || sourceTarget.height <= 0) return sourceCanvas;
    if (sourceCanvas.width <= 0 || sourceCanvas.height <= 0) return sourceCanvas;
    const scaleX = sourceCanvas.width / sourceTarget.width;
    const scaleY = sourceCanvas.height / sourceTarget.height;
    const cropWidth = Math.round(viewportWidthCss * scaleX);
    const cropHeight = Math.round(viewportHeightCss * scaleY);
    if (cropWidth <= 0 || cropHeight <= 0) return sourceCanvas;
    const croppedCanvas = document.createElement("canvas");
    croppedCanvas.width = cropWidth;
    croppedCanvas.height = cropHeight;
    const croppedCtx = croppedCanvas.getContext("2d");
    if (!croppedCtx) return sourceCanvas;
    croppedCtx.drawImage(sourceCanvas, -window.scrollX * scaleX, -window.scrollY * scaleY);
    return croppedCanvas;
  }
  function downscaleCanvasToMaxEdge(sourceCanvas, maxEdgePx) {
    const longestEdge = Math.max(sourceCanvas.width, sourceCanvas.height);
    if (longestEdge <= 0 || longestEdge <= maxEdgePx) return sourceCanvas;
    const scale = maxEdgePx / longestEdge;
    const scaledWidth = Math.max(1, Math.round(sourceCanvas.width * scale));
    const scaledHeight = Math.max(1, Math.round(sourceCanvas.height * scale));
    const scaledCanvas = document.createElement("canvas");
    scaledCanvas.width = scaledWidth;
    scaledCanvas.height = scaledHeight;
    const scaledCtx = scaledCanvas.getContext("2d");
    if (!scaledCtx) return sourceCanvas;
    scaledCtx.drawImage(sourceCanvas, 0, 0, scaledWidth, scaledHeight);
    return scaledCanvas;
  }
  function encodeCanvasUnderByteCap(sourceCanvas) {
    let canvas = sourceCanvas;
    let base64 = extractBase64FromDataUrl(canvas.toDataURL("image/png"));
    for (let attempt = 0; attempt < MAX_BYTE_CAP_RE_ENCODE_ATTEMPTS; attempt++) {
      if (base64.length <= MAX_ENCODED_IMAGE_BASE64_BYTES) break;
      const longestEdge = Math.max(canvas.width, canvas.height);
      if (longestEdge <= MIN_ENCODED_IMAGE_EDGE_PX) break;
      const ratio = Math.sqrt(MAX_ENCODED_IMAGE_BASE64_BYTES / base64.length) * 0.9;
      const scale = Math.min(0.9, Math.max(0.4, ratio));
      const nextEdge = Math.max(MIN_ENCODED_IMAGE_EDGE_PX, Math.round(longestEdge * scale));
      if (nextEdge >= longestEdge) break;
      const shrunk = downscaleCanvasToMaxEdge(canvas, nextEdge);
      if (shrunk === canvas) break;
      canvas = shrunk;
      base64 = extractBase64FromDataUrl(canvas.toDataURL("image/png"));
    }
    return {
      base64,
      width: canvas.width,
      height: canvas.height,
      withinCap: base64.length <= MAX_ENCODED_IMAGE_BASE64_BYTES
    };
  }
  function measureCaptureTarget(element) {
    const rect = element.getBoundingClientRect();
    return {
      element,
      width: Math.ceil(Math.max(
        finiteDimension(rect.width),
        finiteDimension(element.scrollWidth),
        finiteDimension(element.clientWidth)
      )),
      height: Math.ceil(Math.max(
        finiteDimension(rect.height),
        finiteDimension(element.scrollHeight),
        finiteDimension(element.clientHeight)
      ))
    };
  }
  function hasPositiveDimensions({ width, height }) {
    return width > 0 && height > 0;
  }
  function resolveCaptureTargetCandidates(fullPage) {
    const documentElementTarget = measureCaptureTarget(document.documentElement);
    if (fullPage) {
      return [documentElementTarget];
    }
    const bodyTarget = document.body ? measureCaptureTarget(document.body) : null;
    const candidates = [];
    if (bodyTarget) {
      candidates.push(bodyTarget);
    }
    if (!bodyTarget || bodyTarget.element !== documentElementTarget.element) {
      candidates.push(documentElementTarget);
    }
    return candidates;
  }
  function resolveCaptureTarget(fullPage) {
    const candidates = resolveCaptureTargetCandidates(fullPage);
    return candidates.find(hasPositiveDimensions) ?? candidates[0];
  }
  function sleep(ms) {
    return new Promise((resolve2) => setTimeout(resolve2, ms));
  }
  async function waitForUsableCaptureTarget(fullPage) {
    const deadline = Date.now() + CAPTURE_TARGET_LAYOUT_READY_TIMEOUT_MS;
    let captureTarget = resolveCaptureTarget(fullPage);
    while (!hasPositiveDimensions(captureTarget) && Date.now() < deadline) {
      await sleep(CAPTURE_TARGET_LAYOUT_READY_POLL_INTERVAL_MS);
      captureTarget = resolveCaptureTarget(fullPage);
    }
    return {
      target: hasPositiveDimensions(captureTarget) ? captureTarget : null,
      lastMeasurement: captureTarget
    };
  }
  function buildNotVisuallyReadyResult(message) {
    return {
      success: false,
      error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.TIMEOUT,
      data: { message }
    };
  }
  async function waitForFiniteAnimationsToSettle() {
    if (typeof document.getAnimations !== "function") return;
    const finiteRunning = document.getAnimations().filter((animation) => {
      const iterations = animation.effect?.getTiming().iterations;
      return iterations !== Infinity && animation.playState === "running";
    });
    if (finiteRunning.length === 0) return;
    await Promise.race([
      Promise.allSettled(finiteRunning.map((animation) => animation.finished)),
      sleep(ANIMATION_SETTLE_TIMEOUT_MS)
    ]);
  }
  function countVisibleLayoutElementsInViewport() {
    const viewportWidth = window.innerWidth;
    const viewportHeight = window.innerHeight;
    let visibleCount = 0;
    for (const element of Array.from(document.body?.querySelectorAll("*") ?? [])) {
      const rect = element.getBoundingClientRect();
      const intersectsViewport = rect.width > 0 && rect.height > 0 && rect.bottom > 0 && rect.right > 0 && rect.top < viewportHeight && rect.left < viewportWidth;
      if (intersectsViewport) {
        visibleCount++;
        if (visibleCount >= MIN_VISIBLE_LAYOUT_ELEMENTS) return visibleCount;
      }
    }
    return visibleCount;
  }
  function isCanvasBlankRender(canvas) {
    const sampleCanvas = document.createElement("canvas");
    sampleCanvas.width = BLANK_DETECTION_SAMPLE_SIZE;
    sampleCanvas.height = BLANK_DETECTION_SAMPLE_SIZE;
    const sampleCtx = sampleCanvas.getContext("2d");
    if (!sampleCtx) {
      return false;
    }
    sampleCtx.drawImage(canvas, 0, 0, BLANK_DETECTION_SAMPLE_SIZE, BLANK_DETECTION_SAMPLE_SIZE);
    const { data } = sampleCtx.getImageData(0, 0, BLANK_DETECTION_SAMPLE_SIZE, BLANK_DETECTION_SAMPLE_SIZE);
    const totalPixels = BLANK_DETECTION_SAMPLE_SIZE * BLANK_DETECTION_SAMPLE_SIZE;
    let blankPixelCount = 0;
    for (let i = 0; i < data.length; i += 4) {
      const r = data[i];
      const g = data[i + 1];
      const b = data[i + 2];
      const a = data[i + 3];
      if (a === 0 || r > 245 && g > 245 && b > 245) {
        blankPixelCount++;
      }
    }
    const blankRatio = blankPixelCount / totalPixels;
    if (blankRatio < BLANK_PIXEL_RATIO_THRESHOLD) {
      return false;
    }
    const domTextLength = document.body?.textContent?.trim().length ?? 0;
    if (domTextLength <= DOM_CONTENT_MIN_CHARS) {
      return false;
    }
    return countVisibleLayoutElementsInViewport() >= MIN_VISIBLE_LAYOUT_ELEMENTS;
  }
  function renderToCanvasWithTimeout(targetElement) {
    const renderPromise = domToCanvas(targetElement, {
      timeout: RENDER_ASSET_FETCH_TIMEOUT_MS,
      fetch: {
        bypassingCache: true
      }
    });
    let outerTimeoutId;
    const timeoutPromise = new Promise((_resolveNever, rejectOnTimeout) => {
      outerTimeoutId = setTimeout(() => {
        rejectOnTimeout(new Error(`screenshot timed out after ${DOM_TO_CANVAS_TOTAL_TIMEOUT_MS}ms`));
      }, DOM_TO_CANVAS_TOTAL_TIMEOUT_MS);
    });
    return Promise.race([renderPromise, timeoutPromise]).finally(() => clearTimeout(outerTimeoutId));
  }
  async function renderUsableCanvasWithRetries(initialTarget, fullPage) {
    const deadline = Date.now() + ZERO_SIZE_RENDER_RETRY_TIMEOUT_MS;
    let preferredTarget = initialTarget;
    let lastZeroSizeCanvas = null;
    while (true) {
      const fallbackTargets = resolveCaptureTargetCandidates(fullPage).filter((candidate) => candidate.element !== preferredTarget.element).filter(hasPositiveDimensions);
      const targetsToTry = [preferredTarget, ...fallbackTargets].filter(hasPositiveDimensions);
      for (const candidate of targetsToTry) {
        const renderedCanvas = await renderToCanvasWithTimeout(candidate.element);
        if (hasPositiveDimensions(renderedCanvas)) {
          return { canvas: renderedCanvas, usedTarget: candidate, lastZeroSizeCanvas };
        }
        lastZeroSizeCanvas = renderedCanvas;
      }
      if (Date.now() >= deadline) {
        return { canvas: null, usedTarget: null, lastZeroSizeCanvas };
      }
      await sleep(ZERO_SIZE_RENDER_RETRY_INTERVAL_MS);
      preferredTarget = resolveCaptureTarget(fullPage);
    }
  }
  async function executePreviewLensScreenshot(rawArgs) {
    const screenshotArgs = rawArgs;
    try {
      if (document.hidden || window.innerWidth === 0 || window.innerHeight === 0) {
        return {
          success: false,
          error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.IFRAME_HIDDEN,
          data: {
            message: "the preview surface is hidden or zero-size (preview panel closed, or the tab is showing another view) \u2014 a screenshot is physically impossible right now. DO NOT retry preview_screenshot; use preview_execute_code with window.__base44_preview.domSnapshot() / .inspect(selector) for non-visual checks, or ask the user to open the preview."
          }
        };
      }
      const {
        target: captureTarget,
        lastMeasurement
      } = await waitForUsableCaptureTarget(Boolean(screenshotArgs.full_page));
      if (!captureTarget) {
        return buildNotVisuallyReadyResult(
          `screenshot target stayed ${lastMeasurement.width}x${lastMeasurement.height} for ${CAPTURE_TARGET_LAYOUT_READY_TIMEOUT_MS}ms; preview is not visually ready yet. Use preview_execute_code with window.__base44_preview.consoleLogs({level: 'error'}) if you need browser-side errors, then retry once later before claiming visual verification.`
        );
      }
      if (document.fonts?.ready) {
        await Promise.race([document.fonts.ready, sleep(FONTS_READY_TIMEOUT_MS)]);
      }
      await waitForFiniteAnimationsToSettle();
      const { canvas: renderedCanvas, usedTarget, lastZeroSizeCanvas } = await renderUsableCanvasWithRetries(
        captureTarget,
        Boolean(screenshotArgs.full_page)
      );
      if (!renderedCanvas) {
        const lastSize = lastZeroSizeCanvas ? `${lastZeroSizeCanvas.width}x${lastZeroSizeCanvas.height}` : `${captureTarget.width}x${captureTarget.height}`;
        return buildNotVisuallyReadyResult(
          `screenshot renderer kept returning a zero-size canvas (${lastSize}) for ${ZERO_SIZE_RENDER_RETRY_TIMEOUT_MS}ms; preview may still be warming or laying out. Use preview_execute_code with window.__base44_preview.consoleLogs({level: 'error'}) if you need browser-side errors, then retry once later before claiming visual verification.`
        );
      }
      const canvasToReturn = screenshotArgs.full_page ? renderedCanvas : cropCanvasToViewport(renderedCanvas, usedTarget ?? captureTarget);
      if (isCanvasBlankRender(canvasToReturn)) {
        return {
          success: false,
          error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.BLANK_RENDER,
          data: {
            message: "screenshot rendered a uniform white/transparent canvas despite the page having visible content (renderer misfired \u2014 page may still be mounting or a cross-origin asset failed). Use preview_execute_code with window.__base44_preview.navigate() to reload, then retry once; use window.__base44_preview.domSnapshot() to inspect actual content."
          }
        };
      }
      const edgeCappedCanvas = downscaleCanvasToMaxEdge(canvasToReturn, MAX_CANVAS_EDGE_PX);
      const { base64: pngBase64, width: encodedWidth, height: encodedHeight, withinCap } = encodeCanvasUnderByteCap(edgeCappedCanvas);
      if (!withinCap) {
        return {
          success: false,
          error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.BRIDGE_ERROR,
          data: {
            message: "screenshot payload exceeded the transport limit even after downscaling to the minimum size, so it was not sent (an oversized image is dropped in transit). If you used full_page, retry without it (viewport-only is smaller); otherwise use preview_execute_code with window.__base44_preview.domSnapshot() / .inspect() to inspect content without an image."
          }
        };
      }
      return {
        success: true,
        data: {
          base64: pngBase64,
          width: encodedWidth,
          height: encodedHeight
        }
      };
    } catch (caughtError) {
      const errorMessage = caughtError instanceof Error ? caughtError.message : String(caughtError);
      const isTimeoutError = errorMessage.includes("timed out");
      const isKnownUtf8EncodeDefect = /illegal UTF-?8/i.test(errorMessage);
      return {
        success: false,
        error: isTimeoutError ? PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.TIMEOUT : PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.BRIDGE_ERROR,
        // modern-screenshot errors can embed the failing resource URL (signed token-bearing).
        // Redact before it crosses into the tool result + logs, like the other PreviewLens output paths.
        data: {
          message: isKnownUtf8EncodeDefect ? `screenshot renderer failed encoding page content (${redactString(errorMessage)}). This is a renderer limitation with unusual characters on the page \u2014 do not retry preview_screenshot on this page; use preview_execute_code with window.__base44_preview.domSnapshot() / .inspect() instead.` : redactString(errorMessage),
          ...isKnownUtf8EncodeDefect ? { known_issue: "modern_screenshot_utf8_encode" } : {}
        }
      };
    }
  }

  // src/builder-bridge/preview-lens-executor.ts
  var TRUSTED_PARENT_ORIGIN_PATTERNS = [
    // localhost/127.0.0.1 keep http (local dev has no TLS); prod/staging domains
    // are https-only — a network MitM serving http://base44.com (no HSTS cached)
    // must not pass the parent check for data-returning ops (execute_code/screenshot).
    /^https?:\/\/localhost(:\d+)?$/,
    /^https?:\/\/127\.0\.0\.1(:\d+)?$/,
    /^https:\/\/([a-zA-Z0-9-]+\.)*base44\.com$/,
    /^https:\/\/([a-zA-Z0-9-]+\.)*velino\.org$/
  ];
  function isOriginTrustedForPreviewLens(origin) {
    return TRUSTED_PARENT_ORIGIN_PATTERNS.some((pattern) => pattern.test(origin));
  }
  function requiresTrustedParentOrigin(op) {
    return op !== "ping";
  }
  var OP_TO_EXECUTOR = {
    screenshot: executePreviewLensScreenshot,
    execute_code: executePreviewLensEval,
    resize: (args, parentOrigin) => executePreviewLensResize(args, parentOrigin),
    console_logs: executePreviewLensConsoleLogs,
    ping: () => executePreviewLensPing()
  };
  function isPreviewLensCommandMessage(messageData) {
    if (typeof messageData !== "object" || messageData === null) return false;
    const messageRecord = messageData;
    return messageRecord.type === "preview_lens_cmd" && typeof messageRecord.command_id === "string" && typeof messageRecord.op === "string";
  }
  function postPreviewLensResultToParent(resultMessage, targetOrigin) {
    if (!window.parent || window.parent === window) return;
    window.parent.postMessage(resultMessage, targetOrigin);
  }
  function visibilityTelemetry() {
    return {
      document_hidden: document.hidden,
      viewport_zero: window.innerWidth === 0 || window.innerHeight === 0
    };
  }
  function withVisibilityOnFailure(success, data) {
    if (success) return data;
    const dataRecord = data && typeof data === "object" && !Array.isArray(data) ? data : data === void 0 ? {} : { raw: data };
    return { ...visibilityTelemetry(), ...dataRecord };
  }
  async function executeOpAndBuildResult(previewLensCommand, parentOrigin = "*") {
    const executorFunction = OP_TO_EXECUTOR[previewLensCommand.op];
    if (!executorFunction) {
      return {
        type: "preview_lens_result",
        command_id: previewLensCommand.command_id,
        success: false,
        error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.BRIDGE_ERROR,
        data: withVisibilityOnFailure(false, { message: `unknown op: ${previewLensCommand.op}` })
      };
    }
    try {
      const executorResult = await executorFunction(previewLensCommand.args ?? {}, parentOrigin);
      return {
        type: "preview_lens_result",
        command_id: previewLensCommand.command_id,
        success: executorResult.success,
        data: withVisibilityOnFailure(executorResult.success, executorResult.data),
        error: executorResult.error
      };
    } catch (uncaughtExecutorError) {
      return {
        type: "preview_lens_result",
        command_id: previewLensCommand.command_id,
        success: false,
        error: PREVIEW_LENS_EXECUTOR_ERROR_CATEGORIES.BRIDGE_ERROR,
        data: withVisibilityOnFailure(false, {
          message: uncaughtExecutorError instanceof Error ? uncaughtExecutorError.message : String(uncaughtExecutorError)
        })
      };
    }
  }
  async function handleIncomingPostMessage(messageEvent) {
    if (!isPreviewLensCommandMessage(messageEvent.data)) return;
    const previewLensCommand = messageEvent.data;
    if (isOriginTrustedForPreviewLens(messageEvent.origin)) {
      lastTrustedParentOrigin = messageEvent.origin;
    }
    if (requiresTrustedParentOrigin(previewLensCommand.op) && !isOriginTrustedForPreviewLens(messageEvent.origin)) {
      console.warn(
        `[BuilderBridge] preview_lens_cmd ${previewLensCommand.op} rejected: untrusted origin ${messageEvent.origin}`
      );
      return;
    }
    const resultMessage = await executeOpAndBuildResult(previewLensCommand, messageEvent.origin);
    postPreviewLensResultToParent(resultMessage, messageEvent.origin);
  }
  var lastTrustedParentOrigin = null;
  function deriveTrustedParentOrigin() {
    const candidates = [];
    const ancestorOrigin = window.location.ancestorOrigins?.[0];
    if (ancestorOrigin) candidates.push(ancestorOrigin);
    try {
      if (document.referrer) candidates.push(new URL(document.referrer).origin);
    } catch {
    }
    return candidates.find(isOriginTrustedForPreviewLens) ?? null;
  }
  function getTrustedParentOrigin() {
    return lastTrustedParentOrigin;
  }
  var isExecutorInstalled = false;
  function installPreviewLensExecutor() {
    if (isExecutorInstalled) return;
    isExecutorInstalled = true;
    window.addEventListener("message", (messageEvent) => {
      void handleIncomingPostMessage(messageEvent);
    });
    if (lastTrustedParentOrigin === null) {
      lastTrustedParentOrigin = deriveTrustedParentOrigin();
    }
  }
  installPreviewLensExecutor();

  // src/builder-bridge/preview-lens/navigationObserver.ts
  var PREVIEW_LENS_NAVIGATION_STARTED = "PREVIEW_LENS_NAVIGATION_STARTED";
  var PREVIEW_LENS_ROUTE_RENDERED = "PREVIEW_LENS_ROUTE_RENDERED";
  var isInstalled = false;
  var lastObservedUrl = "";
  var navigationEpoch = 0;
  function postToParent(getParentOrigin, message) {
    const parentOrigin = getParentOrigin();
    if (!parentOrigin) return;
    if (!window.parent || window.parent === window) return;
    window.parent.postMessage(message, parentOrigin);
  }
  async function handleRouteChange(getParentOrigin, url = currentRelativeUrl()) {
    if (url === lastObservedUrl) return;
    lastObservedUrl = url;
    const epoch = navigationEpoch += 1;
    const rootRerender = observeRootRerender(ROUTE_RENDER_TIMEOUT_MS);
    noteRouteChangePending(url, rootRerender.settled);
    postToParent(getParentOrigin, {
      type: PREVIEW_LENS_NAVIGATION_STARTED,
      path: new URL(url, window.location.origin).pathname
    });
    const rendered = await rootRerender.settled;
    if (epoch !== navigationEpoch) return;
    if (!rendered) return;
    if (url !== currentRelativeUrl()) return;
    noteRouteRenderConfirmed(url);
  }
  function hashChangeRelativeUrl(event) {
    try {
      const changedUrl = new URL(event.newURL || window.location.href, window.location.href);
      return changedUrl.pathname + changedUrl.search + changedUrl.hash;
    } catch {
      return currentRelativeUrl();
    }
  }
  function installPreviewLensNavigationObserver(getParentOrigin) {
    if (isInstalled) return () => {
    };
    isInstalled = true;
    lastObservedUrl = currentRelativeUrl();
    setRenderConfirmedListener(() => {
      postToParent(getParentOrigin, {
        type: PREVIEW_LENS_ROUTE_RENDERED,
        path: window.location.pathname
      });
    });
    const onRouteChange = () => {
      void handleRouteChange(getParentOrigin);
    };
    const onHashChange = (event) => {
      void handleRouteChange(getParentOrigin, hashChangeRelativeUrl(event));
    };
    const originalPushState = history.pushState.bind(history);
    const originalReplaceState = history.replaceState.bind(history);
    history.pushState = function patchedPushState(...args) {
      const result2 = originalPushState(...args);
      onRouteChange();
      return result2;
    };
    history.replaceState = function patchedReplaceState(...args) {
      const result2 = originalReplaceState(...args);
      onRouteChange();
      return result2;
    };
    window.addEventListener("popstate", onRouteChange);
    window.addEventListener("hashchange", onHashChange);
    return () => {
      history.pushState = originalPushState;
      history.replaceState = originalReplaceState;
      window.removeEventListener("popstate", onRouteChange);
      window.removeEventListener("hashchange", onHashChange);
      setRenderConfirmedListener(null);
      isInstalled = false;
    };
  }

  // src/builder-bridge/index.ts
  var currentScript = document.currentScript;
  var AUTH_401_THROTTLE_MS = 3e4;
  var last401SignalTime = 0;
  var PREVIEW_AUTH_FAILURE_MESSAGE = "Unauthorized: Invalid or missing preview authentication";
  function extract401ProxyUrl(event) {
    if (event.type !== EventType.Plugin) return null;
    const data = event.data;
    if (data?.plugin !== PLUGIN_NAME2) return null;
    const request = data.payload?.payload;
    if (request?.status !== 401 || typeof request?.url !== "string") return null;
    if (!request.responseBody?.includes(PREVIEW_AUTH_FAILURE_MESSAGE)) return null;
    return request.url;
  }
  function sendToParent(type, payload) {
    if (!window.parent || window.parent === window) {
      console.warn("[BuilderBridge] No parent window found");
      return;
    }
    const message = { type, payload };
    window.parent.postMessage(message, "*");
  }
  function init() {
    startRecording((event) => {
      const proxyUrl = extract401ProxyUrl(event);
      if (proxyUrl && Date.now() - last401SignalTime > AUTH_401_THROTTLE_MS) {
        last401SignalTime = Date.now();
        sendToParent("SANDBOX_401", { url: proxyUrl });
      }
    });
    setupReactInspector();
    const dataset = currentScript?.dataset;
    if (dataset?.rumAppId && dataset?.rumClientToken && dataset?.appId) {
      initPageNotFoundTracker({
        appId: dataset.appId,
        previewType: dataset.previewType ?? "",
        rumAppId: dataset.rumAppId,
        rumClientToken: dataset.rumClientToken,
        ddSite: dataset.ddSite ?? "datadoghq.com",
        onPageNotFound: (ctx) => sendToParent("PREVIEW_PAGE_NOT_FOUND", ctx)
      });
    }
    if (dataset?.previewType === "sandbox") {
      installPreviewLensNavigationObserver(getTrustedParentOrigin);
    }
    initEngagementTracker(sendToParent);
    initKeyboardInputScroll();
    window.addEventListener("pagehide", () => sendToParent("BRIDGE_UNLOADING"));
    sendToParent("BRIDGE_READY", { version: "1.0.0" });
  }
  init();
})();
/*! Bundled license information:

rrweb/dist/rrweb.js:
  (*! *****************************************************************************
  Copyright (c) Microsoft Corporation.
  
  Permission to use, copy, modify, and/or distribute this software for any
  purpose with or without fee is hereby granted.
  
  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  PERFORMANCE OF THIS SOFTWARE.
  ***************************************************************************** *)
*/
//# sourceMappingURL=builder-bridge.js.map